TimeConstrainedModule.cpp

Go to the documentation of this file.

// TimeConstrainedModule.cpp: implementation of the TimeConstrainedModule class.
//
 
#include "TimeConstrainedModule.h"
#include "../Procedure/ExpectedMentalBelief.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(TimeConstrainedModule)
using namespace std;
 
 
// Construction/Destruction
 
TimeConstrainedModule::TimeConstrainedModule()
{
    Time_Constrained_PIF_Value = 0.0;
    Last_Update_Time = 0.0;
    Time_Lapse_for_Update = 0.0;
}
 
TimeConstrainedModule::~TimeConstrainedModule()
{
    this->clearTimeConstrainedData();
}
 
void TimeConstrainedModule::clearTimeConstrainedData()
{
    Time_Constrained_Parameter_Array.clear();
    Time_Constrained_PIF_Value = 0.0;
    Last_Update_Time = 0.0;
    Time_Lapse_for_Update = 0.0;
}
void TimeConstrainedModule::updateRawDataAndCalculateTimeToThreshold(InfoChunk *_perceived_info){
    int goal;
    ExpectedMentalBelief *emb_ptr = 0;
    bool reactor_tripped = false;
    goal = _perceived_info->getCurrentGoal();
    //
    // Check status of reactor (on line or tripped)
    emb_ptr = _perceived_info->checkExistanceOfMentalBelief("Reactor_Tripped");
    if (emb_ptr != 0 )
    {
        if (emb_ptr->getStateOfActivation() == sim::State::Succeed) {
            reactor_tripped = true;
        }
    }
    //
    for(auto& item : Time_Constrained_Parameter_Array){
        item->updateRawData(Time_Lapse_for_Update, _perceived_info);
        item->CalculateTimeToThreshold();
        item->CalculateTimeConstrainedUnitPIFValue(goal, reactor_tripped, this->getTimeLapseForUpdate());
    }
}
 
void TimeConstrainedModule::operatorUpdateTimeConstrainedValuesWithGoal(InfoChunk *_perceived_info)
{
    double TCL_unit_value;
    double new_TCL_value = 0.0;
    if ((r5pars_.timesno - Last_Update_Time) >= Time_Lapse_for_Update)
    {
        Last_Update_Time = r5pars_.timesno;
        this->updateRawDataAndCalculateTimeToThreshold(_perceived_info);
        for(auto& item : Time_Constrained_Parameter_Array)
        {
            TCL_unit_value = item->getTimeConstrainedUnitPIFValue();
            new_TCL_value = fmax(new_TCL_value,TCL_unit_value);
        }
        Time_Constrained_PIF_Value = new_TCL_value;
    }
 
}
 
string TimeConstrainedModule::determineLimitingTimeConstrainedParameter() {
    string limiting_parameter = "NONE";
    double max_PIF = 0.0;
    for (auto& item : Time_Constrained_Parameter_Array){
        if(item->getTimeConstrainedUnitPIFValue() > max_PIF) {
            max_PIF = item->getTimeConstrainedUnitPIFValue();
            limiting_parameter = item->getCorrespondingIndicatorName();
        }
    }
    if (limiting_parameter == "NONE") {
        max_PIF = 0.0;
    }
    return limiting_parameter;
}
 
void TimeConstrainedModule::setTimeLapseForUpdate(double x) {Time_Lapse_for_Update = x;}
double TimeConstrainedModule::getTimeLapseForUpdate() {return Time_Lapse_for_Update;}
double TimeConstrainedModule::getTimeConstrainedPIFValue(){return Time_Constrained_PIF_Value;}
void TimeConstrainedModule::setTimeConstrainedPIFValue(double x) {Time_Constrained_PIF_Value = x;}
void TimeConstrainedModule::copyTimeConstrainedData(TimeConstrainedModule &_Time_Constrained_Data)
{
    for(auto& src : _Time_Constrained_Data.Time_Constrained_Parameter_Array)
    {
        auto time_constrained_unit_pt = make_unique<TimeConstrainedUnit>();
        time_constrained_unit_pt->copyTimeConstrainedUnit(*src);
        Time_Constrained_Parameter_Array.push_back(std::move(time_constrained_unit_pt));
    }
    Time_Constrained_PIF_Value = _Time_Constrained_Data.getTimeConstrainedPIFValue();
    Last_Update_Time = _Time_Constrained_Data.getLastUpdateTime();
    Time_Lapse_for_Update = _Time_Constrained_Data.getTimeLapseForUpdate();
}
 
double TimeConstrainedModule::getLastUpdateTime() {return Last_Update_Time;}
void TimeConstrainedModule::setLastUpdateTime(double x) {Last_Update_Time = x;}
void TimeConstrainedModule::outputTimeConstrainedLabelToFile(string str, ofstream &fout)
{
    //  Module used to output column headers to key parameter file
    int i;
    //  Data Label for Control Panel Based Time Constrained Load
    fout << '\t'<<str<<"Time_Constrained_PIF_Value";
    for(i = 0; i < Time_Constrained_Parameter_Array.size(); i++)
    {
        fout << '\t' << str << Time_Constrained_Parameter_Array.at(i)->getTimeConstrainedUnitName() << "(Value)"
             << '\t' << str << Time_Constrained_Parameter_Array.at(i)->getTimeConstrainedUnitName() << "(Rate)"
             << '\t' << str << Time_Constrained_Parameter_Array.at(i)->getTimeConstrainedUnitName() << "(Normal)"
             << '\t' << str << Time_Constrained_Parameter_Array.at(i)->getTimeConstrainedUnitName() << "(Accident)";
    }
 
}
void TimeConstrainedModule::outputTimeConstrainedUnitsToFile(ofstream &fout)
{
    int i;
    fout << "\t Range:_0-10";
    for(i = 0; i < Time_Constrained_Parameter_Array.size(); i++){
        fout << "\t --" << "\t --" << "\tMinutes to Threshold" << "\tMinutes to Threshold";
    }
 
}
void TimeConstrainedModule::initiationForSimulation(string _file_name)
{
    int i;
    int num_time_constrained_parameters, num_history_data_points;
    double lower_threshold, upper_threshold, decay_tau, buildup_tau;
    TimeConstrainedUnit *time_constrained_array_ptr;
    num_history_data_points = 10;
    string str;
    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();
    }
    else {
        fin >> str >> num_time_constrained_parameters 
            >> str >> Time_Lapse_for_Update;
        fin >> str >> lower_threshold;
        fin >> str >> upper_threshold;
        fin >> str >> decay_tau;
        fin >> str >> buildup_tau;
        for (i = 0; i < num_time_constrained_parameters; i++){
            auto time_constrained_array_ptr = make_unique<TimeConstrainedUnit>();
            time_constrained_array_ptr->readInfoFromFile(fin);
            time_constrained_array_ptr->setLowerTimeThreshold(lower_threshold);
            time_constrained_array_ptr->setUpperTimeThreshold(upper_threshold);
            time_constrained_array_ptr->setDecayTau(decay_tau);
            time_constrained_array_ptr->setBuildupTau(buildup_tau);
//          for (int j=0; j< num_history_data_points; j++)
//          {
//              time_constrained_array_ptr->time_constrained_parameter_history.push_back(time_constrained_array_ptr->getInitialParameterValue());
//              time_constrained_array_ptr->time_constrained_time_history.push_back(r5pars_.timesno + (double) (j - (num_history_data_points+1)) * Time_Lapse_for_Update);
//          }
            Time_Constrained_Parameter_Array.push_back(std::move(time_constrained_array_ptr));
        }
        fin.close();
        Last_Update_Time = r5pars_.timesno - Time_Lapse_for_Update;
    }
}
 
void TimeConstrainedModule::saveTimeConstrainedModuleToFile(ofstream &fout){
    fout << this->Time_Constrained_PIF_Value << ' '
    << this->Last_Update_Time << ' '
    << this->Time_Lapse_for_Update << ' '
    << '\n';
    fout << Time_Constrained_Parameter_Array.size() << '\n';
    for(auto& item : Time_Constrained_Parameter_Array){
        item->saveTimeConstrainedUnitToFile(fout);
    }
}
void TimeConstrainedModule::retrieveTimeConstrainedModuleFromFile(ifstream &fin){
    int i, num_obj;
    fin >> Time_Constrained_PIF_Value
        >> Last_Update_Time
        >> Time_Lapse_for_Update;
    fin >> num_obj;
    for(i = 0; i < num_obj;i++){
        auto TimeConstrainedUnit_pt = make_unique<TimeConstrainedUnit>();
        TimeConstrainedUnit_pt->retrieveTimeConstrainedUnitFromFile(fin);
        this->Time_Constrained_Parameter_Array.push_back(std::move(TimeConstrainedUnit_pt));
    }
}