TimeConstrainedUnit.cpp

Go to the documentation of this file.

// TimeConstrainedUnit.cpp: implementation of the TimeConstrainedUnit class.
//
 
#include "TimeConstrainedUnit.h"
#include "../ControlPanel/ControlPanel.h"
#include "../Global/fmodule.h"
#include "../Scheduler/Scheduler.h"
#include "../ControlPanel/SystemDisplay.h"
#include "../ControlPanel/DisplayParameterValue.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(TimeConstrainedUnit)
using namespace std;
 
 
// Construction/Destruction
 
TimeConstrainedUnit::TimeConstrainedUnit()
{
    Normal_Parameter_Threshold = 0.0;
    Accident_Parameter_Threshold = 0.0;
    Initial_Value = 0.0;
    Parameter_Value = 0.0;
    Parameter_Rate =  0.0;
    Time_To_Accident_Threshold = 0.0;
    Time_To_Normal_Threshold = 0.0;
    Time_Constrained_Unit_PIF_Value = 0.0;
    Time_Constrained_Unit_Name = "NONE";
    Corresponding_Indicator_Name = "NONE";
    ptr_to_corresponding_indicator = 0;
    time_threshold_exceeded = 0.0;
    lower_time_threshold = 5.0;
    upper_time_threshold = 25.0;
    decay_tau = 100.0;
    buildup_tau = 50.0;
    threshold_exceeded = false;
}
 
TimeConstrainedUnit::~TimeConstrainedUnit()
{
    this->clearTimeConstrainedUnit();
}
 
double TimeConstrainedUnit::getNormalParameterThreshold() {return Normal_Parameter_Threshold;}
double TimeConstrainedUnit::getAccidentParameterThreshold(){return Accident_Parameter_Threshold;}
double TimeConstrainedUnit::getTimeToNormalThreshold(){return Time_To_Normal_Threshold;}
double TimeConstrainedUnit::getTimeToAccidentThreshold(){return Time_To_Accident_Threshold;}
double TimeConstrainedUnit::getTimeThresholdExceeded() {return time_threshold_exceeded;}
bool TimeConstrainedUnit::getThresholdExceeded() {return threshold_exceeded;}
double TimeConstrainedUnit::getParameterValue() {return Parameter_Value;}
double TimeConstrainedUnit::getParameterRate() {return Parameter_Rate;}
double TimeConstrainedUnit::getInitialParameterValue() {return Initial_Value;}
double TimeConstrainedUnit::getTimeConstrainedUnitPIFValue() {return Time_Constrained_Unit_PIF_Value;}
void TimeConstrainedUnit::setNormalParameterThreshold(double x) {Normal_Parameter_Threshold = x;}
void TimeConstrainedUnit::setAccidentParameterThreshold(double x) {Accident_Parameter_Threshold=x;}
void TimeConstrainedUnit::setThresholdExceeded(bool logic) {threshold_exceeded = logic;}
void TimeConstrainedUnit::setTimeThresholdExceeded(double x) {time_threshold_exceeded = x;}
void TimeConstrainedUnit::setParameterRate(double x) {Parameter_Rate = x;}
double TimeConstrainedUnit::getLowerTimeThreshold() {return lower_time_threshold;}
double TimeConstrainedUnit::getUpperTimeThreshold() {return upper_time_threshold;}
double TimeConstrainedUnit::getDecayTau() {return decay_tau;}
double TimeConstrainedUnit::getBuildupTau() {return buildup_tau;}
void TimeConstrainedUnit::setLowerTimeThreshold(double x) {lower_time_threshold = x;}
void TimeConstrainedUnit::setUpperTimeThreshold(double x) {upper_time_threshold = x;}
void TimeConstrainedUnit::setDecayTau(double x) {decay_tau = x;} 
void TimeConstrainedUnit::setBuildupTau(double x) {buildup_tau = x;}
 
void TimeConstrainedUnit::updateRawData(double _Time_Lapse, InfoChunk *_perceived_info){
    //
    double _current_time = r5pars_.timesno;
    int num_history_data_points = 10;
    MentalParameterValue *mpv_ptr = 0;
    DisplayParameterValue *dpv_ptr = 0;
    //
    if (time_constrained_parameter_history.size() == 0) {
        for (int i=0; i < num_history_data_points; i++) 
        {
            if(this->getPtrToCorrespondingIndicator() == 0){
                this->setPtrToCorrespondingIndicator((SystemDisplay *) g_sim.Indicator.indicators.getDisplayFromMap(this->getCorrespondingIndicatorName()));
            }
            if (this->getPtrToCorrespondingIndicator() != 0){
                dpv_ptr = (DisplayParameterValue *) this->getPtrToCorrespondingIndicator();
                Parameter_Value = dpv_ptr->getDisplayedParameterValue();
            }
            else {
                cout << "TimeConstrainedUnit::CalculateTimeToThreshold could not find TimeConstrainedUnit corresponding parameter " << this->getCorrespondingIndicatorName() << endl;
                ofstream fout("err messages.txt", ios::app);
                fout << r5pars_.timesno << "  TimeConstrainedUnit::CalculateTimeToThreshold could not find TimeConstrainedUnit corresponding parameter " << this->getCorrespondingIndicatorName() << '\n';
                fout.close();
            }
            time_constrained_parameter_history.push_back(Parameter_Value);
            time_constrained_time_history.push_back(r5pars_.timesno + (double) (i - (num_history_data_points-1)) * _Time_Lapse);
        }
    }
    else
    {
        mpv_ptr = (*_perceived_info).checkExistanceOfPerceivedParameterValue(this->getCorrespondingIndicatorName());
        if (mpv_ptr != 0) {
            Parameter_Value = (*mpv_ptr).getObservedParameterValue();
            if (mpv_ptr->getTimeAtWhichThisInfoIsPerceived() < this->time_constrained_time_history.at(num_history_data_points -1)) {
                // no new information has been perceived - base parameter value on last value and perceived rate
                Parameter_Value = this->time_constrained_parameter_history.at(num_history_data_points - 1)
                                    + Parameter_Rate * _Time_Lapse / 60.0;
            }
        } else { // if information not perceived, use last data point
            Parameter_Value = this->time_constrained_parameter_history.at(num_history_data_points-1);
        }
 
        time_constrained_parameter_history.push_back(Parameter_Value);
        time_constrained_parameter_history.pop_front();
        time_constrained_time_history.push_back(_current_time);
        time_constrained_time_history.pop_front();
    }
}
 
void TimeConstrainedUnit::CalculateTimeToThreshold()
{
    double x1, x2, x21, x22, x3, x4;
    double upper_limit;  // maximum time to threshold
    SystemDisplay *d_element;
    d_element = 0;
//  Initialize variables for linear regression calculation of parameter trend
    x1 = 0.0;
    x21 = 0.0;
    x22 = 0.0;
    x3 = 0.0;
    x4 = 0.0;
    upper_limit = 1.0E+06;
//
    deque<double>::iterator time_constrained_parameter_history_itr;
    deque<double>::iterator time_history_itr;
//  
//  calculate parameter trend
 
    time_history_itr = time_constrained_time_history.begin();
        
    for(time_constrained_parameter_history_itr = time_constrained_parameter_history.begin(); 
      time_constrained_parameter_history_itr != time_constrained_parameter_history.end(); time_constrained_parameter_history_itr++){
            x1 += (*time_constrained_parameter_history_itr) * (*time_history_itr);
            x21 += (*time_constrained_parameter_history_itr);
            x22 += (*time_history_itr);
            x3 += (*time_history_itr) * (*time_history_itr);
            time_history_itr++;
    }
    x1 *= (double)time_constrained_parameter_history.size();
    x2 = x21 * x22;
    x3 *= (double) time_constrained_parameter_history.size();
    x4 = x22 * x22;
    if (x3 != x4)
    {
        Parameter_Rate = (x1 - x2)/(x3 - x4) * 60.0; // units per minute
        //
        // Calculate Time to Normal threshold
        if(Initial_Value>Normal_Parameter_Threshold) 
        {
            if(Parameter_Value<=Normal_Parameter_Threshold) 
            {
                Time_To_Normal_Threshold = 0.0;
            }
            else 
            {
                if(Parameter_Rate < 0.0) 
                {
                    Time_To_Normal_Threshold = (Normal_Parameter_Threshold - Parameter_Value) / Parameter_Rate;
                }
                else 
                {
                    Time_To_Normal_Threshold = upper_limit;
                }
            }
        }
        else 
        {
            if(Parameter_Value>=Normal_Parameter_Threshold) 
            {
                Time_To_Normal_Threshold = 0.0;
            }
            else 
            {
                if(Parameter_Rate > 0.0) 
                {
                    Time_To_Normal_Threshold = (Normal_Parameter_Threshold - Parameter_Value) / Parameter_Rate;
                }
                else 
                {
                    Time_To_Normal_Threshold = upper_limit;
                }
            }
        }
        // Calculate Time to Accident Threshold
        if(Initial_Value>Accident_Parameter_Threshold) 
        {
            if(Parameter_Value<=Accident_Parameter_Threshold) 
            {
                Time_To_Accident_Threshold = 0.0;
                if (!threshold_exceeded) 
                {
                    threshold_exceeded = true;
                    time_threshold_exceeded = r5pars_.timesno;
                }
            }
            else 
            {
                if(threshold_exceeded) 
                {
                    threshold_exceeded = false;
                }
                if(Parameter_Rate<0.0) 
                {
                    Time_To_Accident_Threshold = (Accident_Parameter_Threshold - Parameter_Value) / Parameter_Rate;
                }
                else 
                {
                    Time_To_Accident_Threshold = upper_limit;
                }
            }
        }
        else  
        {
            if(Parameter_Value>=Accident_Parameter_Threshold) 
            {
                Time_To_Accident_Threshold = 0.0;
                if (!threshold_exceeded) 
                {
                    threshold_exceeded = true;
                    time_threshold_exceeded = r5pars_.timesno;
                }
            }
            else 
            {
                if (threshold_exceeded) 
                {
                    threshold_exceeded = false;
                }
                if(Parameter_Rate > 0.0)
                {
                    Time_To_Accident_Threshold = (Accident_Parameter_Threshold - Parameter_Value) / Parameter_Rate;
                }
                else 
                {   // trend is away from threshold
                    Time_To_Accident_Threshold = upper_limit;
                }
            }
        }
    }
    else 
    {   // Parameter Rate is undefined (potential division by zero error) - special handling required
        if(Initial_Value > Normal_Parameter_Threshold) 
        {
            if(Parameter_Value<=Normal_Parameter_Threshold || ((x1-x2) < 0.0) ) 
            {
                Time_To_Normal_Threshold = 0.0;
            }
            else  
            {
                Time_To_Normal_Threshold = upper_limit;
            }
        }
        else 
        {
            if(Parameter_Value >= Normal_Parameter_Threshold || ((x1 - x2) > 0.0) ) 
            {
                Time_To_Normal_Threshold = 0.0;
            }
            else
            {
                Time_To_Normal_Threshold = upper_limit;
            }
        }
        if(Initial_Value > Accident_Parameter_Threshold ) 
        {
            if(Parameter_Value <= Accident_Parameter_Threshold || ((x1-x2) < 0.0) ) 
            {
                Time_To_Accident_Threshold = 0.0;
                if (!threshold_exceeded) 
                {
                    threshold_exceeded = true;
                    time_threshold_exceeded = r5pars_.timesno;
                }
            }
            else
            {
                Time_To_Accident_Threshold= upper_limit;
                if (threshold_exceeded) 
                {
                    threshold_exceeded = false;
                }
            }
        }
        else 
        {
            if(Parameter_Value >= Accident_Parameter_Threshold || ((x1-x2) > 0.0)) 
            {
                Time_To_Accident_Threshold = 0.0;
                if (!threshold_exceeded) 
                {
                    threshold_exceeded = true;
                    time_threshold_exceeded = r5pars_.timesno;
                }
            }
            else
            {
                Time_To_Accident_Threshold = upper_limit;
                if (threshold_exceeded) 
                {
                    threshold_exceeded = false;
                }
            }
        }
    }
    //
    Time_To_Accident_Threshold = fmin(Time_To_Accident_Threshold, upper_limit);
    Time_To_Normal_Threshold = fmin(Time_To_Normal_Threshold, upper_limit);
}
 
void TimeConstrainedUnit::CalculateTimeConstrainedUnitPIFValue(int _goal, bool _rx_tripped, double _time_lapse) 
{
    double dt;
    double new_unit_pif_value = 0.0;
    if ( _goal == sim::None || _goal== sim::Goal::NormalOp || (_goal == sim::Goal::TroubleShoot && !_rx_tripped) || _goal == sim::Goal::MonitorAbnormal) 
    {   //   goal is "sim::None", Normal Operation, troubleshooting, or monitoring
        if (Time_To_Normal_Threshold <= lower_time_threshold) 
        {
            new_unit_pif_value = 10.0;
        }
        if (Time_To_Normal_Threshold >= upper_time_threshold)
        {
            new_unit_pif_value = 0.0;
        }
        if ((Time_To_Normal_Threshold > lower_time_threshold) && (Time_To_Normal_Threshold < upper_time_threshold)) 
        {
            new_unit_pif_value = 10.0*(upper_time_threshold-Time_To_Normal_Threshold)/(upper_time_threshold- lower_time_threshold);
        }
        //
        // use lag function to determine new PIF value
        Time_Constrained_Unit_PIF_Value += (new_unit_pif_value - Time_Constrained_Unit_PIF_Value)*(fmin(1.0, (_time_lapse/buildup_tau)));
    }
    else if ( _goal == sim::Goal::MaintainGlobalSafetyMargin || (_goal == sim::Goal::TroubleShoot && _rx_tripped)) 
    {   //  goal is other than normal
        if (Time_To_Accident_Threshold <= lower_time_threshold) 
        {
            new_unit_pif_value = 10.0;
        }
        if (Time_To_Accident_Threshold >= upper_time_threshold) 
        {
            new_unit_pif_value = 0.0;
        }
        if ((Time_To_Accident_Threshold > lower_time_threshold) && (Time_To_Accident_Threshold < upper_time_threshold)) 
        {
            new_unit_pif_value = 10.0*(upper_time_threshold-Time_To_Accident_Threshold)/(upper_time_threshold- lower_time_threshold);
        }
        //
        // if the threshold has been exceeded, allow PIF value to exponentially decay
        if (threshold_exceeded) {
            // 
            // allow time constrained load to decay
            dt =  r5pars_.timesno - time_threshold_exceeded;
            Time_Constrained_Unit_PIF_Value  = new_unit_pif_value * pow(2.718,-dt/decay_tau);
        } else {
            //
            // use lag function to determine new PIF value
            Time_Constrained_Unit_PIF_Value += (new_unit_pif_value - Time_Constrained_Unit_PIF_Value)*(fmin(1.0, (_time_lapse/buildup_tau)));
        }
    }
 
}
 
void TimeConstrainedUnit::readInfoFromFile(ifstream &fin) 
{
        fin >> Time_Constrained_Unit_Name >> Corresponding_Indicator_Name 
            >> Initial_Value
            >> Normal_Parameter_Threshold >> Accident_Parameter_Threshold;
}
void TimeConstrainedUnit::copyTimeConstrainedUnit(TimeConstrainedUnit &_TimeConstrainedUnit) 
{
    Normal_Parameter_Threshold = _TimeConstrainedUnit.getNormalParameterThreshold();
    Accident_Parameter_Threshold = _TimeConstrainedUnit.getAccidentParameterThreshold();
    Time_To_Normal_Threshold = _TimeConstrainedUnit.getTimeToNormalThreshold();
    Time_To_Accident_Threshold = _TimeConstrainedUnit.getTimeToAccidentThreshold();
    Time_Constrained_Unit_PIF_Value = _TimeConstrainedUnit.getTimeConstrainedUnitPIFValue();
    time_threshold_exceeded = _TimeConstrainedUnit.getTimeThresholdExceeded();
    threshold_exceeded = _TimeConstrainedUnit.getThresholdExceeded();
    Initial_Value = _TimeConstrainedUnit.getInitialParameterValue();
    Parameter_Value = _TimeConstrainedUnit.getParameterValue();
    Parameter_Rate = _TimeConstrainedUnit.getParameterRate();
    Time_Constrained_Unit_Name = _TimeConstrainedUnit.getTimeConstrainedUnitName();
    Corresponding_Indicator_Name = _TimeConstrainedUnit.getCorrespondingIndicatorName();
    lower_time_threshold = _TimeConstrainedUnit.getLowerTimeThreshold();
    upper_time_threshold = _TimeConstrainedUnit.getUpperTimeThreshold();
    decay_tau = _TimeConstrainedUnit.getDecayTau();
    buildup_tau = _TimeConstrainedUnit.getBuildupTau();
    for(int i = 0; i < _TimeConstrainedUnit.time_constrained_parameter_history.size(); i++){
        this->time_constrained_parameter_history.push_back(_TimeConstrainedUnit.time_constrained_parameter_history.at(i));
        this->time_constrained_time_history.push_back(_TimeConstrainedUnit.time_constrained_time_history.at(i));
    }
}
void TimeConstrainedUnit::setCorrespondingIndicatorName(string str) {Corresponding_Indicator_Name = str;}
string TimeConstrainedUnit::getCorrespondingIndicatorName(){return Corresponding_Indicator_Name;}
void TimeConstrainedUnit::setTimeConstrainedUnitName(string str) {Time_Constrained_Unit_Name = str;}
string TimeConstrainedUnit::getTimeConstrainedUnitName(){return Time_Constrained_Unit_Name;}
void TimeConstrainedUnit::setPtrToCorrespondingIndicator(SystemDisplay* _display_element)
    {ptr_to_corresponding_indicator = _display_element;}
SystemDisplay *TimeConstrainedUnit::getPtrToCorrespondingIndicator(){return ptr_to_corresponding_indicator;}
 
 
void TimeConstrainedUnit::saveTimeConstrainedUnitToFile(ofstream &fout){
    int i_threshold_exceeded = 0;
    double xtemp;
    if (threshold_exceeded) {i_threshold_exceeded = 1;}
    deque <double>::iterator d_itr;
    //
    // ensure double variables do not go out of range
    if (Parameter_Value < 1.0E-30 && Parameter_Value > -1.0E-30) {
        Parameter_Value = 0.0;
    }
    if (Parameter_Rate < 1.0E-30 && Parameter_Rate > -1.0E-30) {
        Parameter_Rate = 0.0;
    }
    if (Initial_Value < 1.0E-30 && Initial_Value > -1.0E-30) {
        Initial_Value = 0.0;
    }
    //
    fout << Normal_Parameter_Threshold      << ' ' 
         << Accident_Parameter_Threshold    << ' ' 
         << Initial_Value                   << ' ' 
         << Parameter_Value                 << ' ' 
         << Parameter_Rate                  << ' ' 
         << Time_To_Accident_Threshold      << ' ' 
         << Time_To_Normal_Threshold        << ' ' 
         << Time_Constrained_Unit_PIF_Value << ' '
         << Time_Constrained_Unit_Name      << ' ' 
         << Corresponding_Indicator_Name    << ' '
         << time_threshold_exceeded         << ' '
         << i_threshold_exceeded            << ' '
         << lower_time_threshold            << ' '
         << upper_time_threshold            << ' '
         << decay_tau                       << ' '
         << buildup_tau                     << '\n';
    fout << time_constrained_parameter_history.size() << '\n';
    for(d_itr = time_constrained_parameter_history.begin(); d_itr != time_constrained_parameter_history.end(); d_itr++){
        xtemp = (*d_itr);
        if (xtemp < 1.0E-30 && xtemp > -1.0E-30) {
            xtemp = 0.0;
        }
        fout << xtemp << ' ';
    }
    fout << '\n';
    fout << time_constrained_time_history.size() << '\n';
    for(d_itr = time_constrained_time_history.begin(); d_itr != time_constrained_time_history.end(); d_itr++){
        xtemp = (*d_itr); 
        if (xtemp < 1.0E-30 && xtemp > -1.0E-30) {
            xtemp = 0.0;
        }
        fout << xtemp << ' ';
    }
    fout << '\n';
}
void TimeConstrainedUnit::retrieveTimeConstrainedUnitFromFile(ifstream &fin){
    int i, num_obj, i_threshold_exceeded;
    double t_value;
    fin >> Normal_Parameter_Threshold  
        >> Accident_Parameter_Threshold  
        >> Initial_Value  
        >> Parameter_Value  
        >> Parameter_Rate  
        >> Time_To_Accident_Threshold  
        >> Time_To_Normal_Threshold 
        >> Time_Constrained_Unit_PIF_Value
        >> Time_Constrained_Unit_Name  
        >> Corresponding_Indicator_Name
        >> time_threshold_exceeded 
        >> i_threshold_exceeded
        >> lower_time_threshold
        >> upper_time_threshold
        >> decay_tau           
        >> buildup_tau;
    if (i_threshold_exceeded == 0) {
        threshold_exceeded = false;}
    else {
        threshold_exceeded = true;
    }
    fin >> num_obj;
    for(i = 0; i < num_obj; i++){
        fin >> t_value;
        time_constrained_parameter_history.push_back(t_value);
    }
    fin >> num_obj;
    for(i = 0; i < num_obj; i++){
        fin >> t_value;
        time_constrained_time_history.push_back(t_value);
    }
    ptr_to_corresponding_indicator = 0;
}
 
 
void TimeConstrainedUnit::clearTimeConstrainedUnit(){
    time_constrained_parameter_history.clear();
    time_constrained_time_history.clear();
    Normal_Parameter_Threshold = 0.0;
    Accident_Parameter_Threshold = 0.0;
    Initial_Value = 0.0;
    Parameter_Value = 0.0;
    Parameter_Rate =  0.0;
    Time_To_Accident_Threshold = 0.0;
    Time_To_Normal_Threshold = 0.0;
    Time_Constrained_Unit_Name = "NONE";
    Corresponding_Indicator_Name = "NONE";
    ptr_to_corresponding_indicator = 0;
}