SPDS.cpp

Go to the documentation of this file.

// SPDS.cpp: implementation of the SPDS class.
//
 
#include "SPDS.h"
#include "../Global/fmodule.h"
#include "../Scheduler/Scheduler.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(SPDS)
using namespace std;
 
 
 
// Construction/Destruction
 
SPDS::SPDS()
{
}
 
SPDS::~SPDS()
{
    this->clearSPDS();
}
void SPDS::clearSPDS(){
    spds_input_array.clear();
    spds_history.clear();
    time.clear();
}
void SPDS::initiationForSimulation(string _str){
    //currently 10 data points are used to calculate the value of SPDS_rate.
    int i;
    this->readInfoFromFile(_str);
    for(i = 0; i < 10; i++){
        spds_history.push_back(0.0);
    }
    for(i = 0; i < 10; i++){
        time.push_back(r5pars_.timesno + (double) (i - 10) * time_lapse_for_update);
    }
    last_update_time = r5pars_.timesno - time_lapse_for_update;
}
void SPDS::updateAllSPDSUnitValues(InfoChunk * _perceived_info_ptr){
    for(auto& elem : spds_input_array){
        elem->calculateSPDSUnitValue(_perceived_info_ptr);
    }
}
 
void SPDS::setTimeLapseForUpdate(double x){time_lapse_for_update = x;}
double SPDS::getTimeLapseForUpdate(){return time_lapse_for_update;}
double SPDS::getSPDSValue(){return SPDS_value;}
double SPDS::getSPDSRate(){return SPDS_rate;}
void SPDS::setSPDSValue(double x){SPDS_value = x;}
void SPDS::SetSPDSRate(double x){SPDS_rate = x;}
 
void SPDS::copySPDS(SPDS &_spds){
    int i;
    for(auto& src : _spds.spds_input_array){
        auto pt = std::make_unique<SPDSUnit>();
        pt->copySPDSUnit(*src);
        spds_input_array.push_back(std::move(pt));
    }
    for(i = 0; i < _spds.spds_history.size(); i++){
        this->spds_history.push_back(_spds.spds_history.at(i));
    }
    for(i = 0; i < _spds.time.size(); i++){
        this->time.push_back(_spds.time.at(i));
    }
    time_lapse_for_update = _spds.getTimeLapseForUpdate();
    SPDS_value = _spds.getSPDSValue();
    SPDS_rate = _spds.getSPDSRate();
    last_update_time = _spds.getLastUpdateTime();
}
 
void SPDS::readInfoFromFile(string _str){
    string str, file_name;
    int i, num_spds_unit;
    ifstream fin(_str.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_spds_unit >> str >> time_lapse_for_update;
        for (i = 0; i < num_spds_unit; i++){
            auto pt = std::make_unique<SPDSUnit>();
            pt->readInfoFromFile(fin);
            spds_input_array.push_back(std::move(pt));
        }
        fin.close();
    }
}
 
double SPDS::getLastUpdateTime(){return last_update_time;}
void SPDS::setLastUpdateTime(double x){last_update_time = x;}
 
void SPDS::updateAllSPDSValueAndRate(InfoChunk * _perceived_info_ptr){
    double total_weight, total_weighted_sum;
    double x1, x2, x21, x22, x3, x4;
    total_weight = 0.0;
    total_weighted_sum = 0.0;
    x1 = 0.0;
    x21 = 0.0;
    x22 = 0.0;
    x3 = 0.0;
    x4 = 0.0;
    deque<double>::iterator spds_history_itr;
    deque<double>::iterator time_itr;
    if ((r5pars_.timesno - last_update_time) >= time_lapse_for_update){
        last_update_time = r5pars_.timesno;
        this->updateAllSPDSUnitValues(_perceived_info_ptr);
        //calculate SPDS_value
        for(auto& elem : spds_input_array){
            total_weight += elem->getSPDSUnitWeight();
            total_weighted_sum += elem->getSPDSUnitWeight() * elem->getSPDSUnitValue();
        }
        SPDS_value = total_weighted_sum/total_weight;
        // ensure SPDS_value is in the range of 0.0 - 10.0
        SPDS_value = fmax(0.0, SPDS_value);
        SPDS_value = fmin(10.0,SPDS_value);
        //calculate SPDS_rate
        spds_history.push_back(SPDS_value);
        spds_history.pop_front();
        time.push_back(last_update_time);
        time.pop_front();
        //
 
        time_itr = time.begin();
        for(spds_history_itr = spds_history.begin(); spds_history_itr != spds_history.end(); spds_history_itr++){
            x1 += (*spds_history_itr) * (*time_itr);
            x21 += (*spds_history_itr);
            x22 += (*time_itr);
            x3 += (*time_itr) * (*time_itr);
            time_itr++;
        }
        x1 *= (double) spds_history.size();
        x2 = x21 * x22;
        x3 *= (double) spds_history.size();
        x4 = x22 * x22;
        if (x3 != x4){
            // find spds_rate from linear regression slope formula (units are % of full scale per minute)
            // range for spds value is 0 to 10
            SPDS_rate = (x1 - x2)/(x3 - x4) * 60.0 * (100. /10.);//per minute
        }
        else{
            SPDS_rate = 0.0;
        }
    }
}
void SPDS::outputSPDSLabelToFile(string str, ofstream &fout){
    int i;
    string str1;
    fout << "\t" << str+ "SPDS_Value"<< "\t" << str + "SPDS_Rate";
    for(i = 0; i < spds_input_array.size(); i++){
        str1 = str + spds_input_array.at(i)->getSPDSUnitName(); 
        fout << '\t' << str1;;
    }
}
void SPDS::outputSPDSUnitToFile(ofstream &fout){
    int i;
    fout << "\t Range:_0-10\t%_Full_Scale_per_minute";
    for(i = 0; i < spds_input_array.size(); i++){
        fout << "\t--";
    }
}
 
void SPDS::saveSPDSToFile(ofstream &fout){
    fout << "SPDS\n"
        << time_lapse_for_update << ' '
        << SPDS_value << ' '
        << SPDS_rate << ' '
        << last_update_time << '\n';
    fout << this->spds_input_array.size() << '\n';
    for(auto& elem : spds_input_array){
        elem->saveSPDSUnitToFile(fout);
    }
    fout << this->spds_history.size() << '\n';
    for(auto& val : spds_history){
        fout << val << ' ';
    }
    fout << '\n';
    fout << this->time.size() << '\n';
    for(auto& val : time){
        fout << val << ' ';
    }
    fout << '\n';
}
void SPDS::retrieveSPDSFromFile(ifstream &fin){
    int i, num_obj;
    double t_value;
    string str;
    fin >> str
        >> time_lapse_for_update
        >> SPDS_value
        >> SPDS_rate
        >> last_update_time;
    fin >> num_obj;
    for(i = 0; i < num_obj; i++){
        auto pt = std::make_unique<SPDSUnit>();
        pt->retrieveSPDSUnitFromFile(fin);
        this->spds_input_array.push_back(std::move(pt));
    }
    fin >> num_obj;
    for(i = 0; i < num_obj; i++){
        fin >> t_value;
        this->spds_history.push_back(t_value);
    }
    fin >> num_obj;
    for(i = 0; i < num_obj; i++){
        fin >> t_value;
        this->time.push_back(t_value);
    }
}