InformationLoadModule.cpp

Go to the documentation of this file.

// InformationLoadModule.cpp: implementation of the InformationLoadModule class.
//
 
#include "InformationLoadModule.h"
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(InformationLoadModule)
using namespace std;
 
// Construction/Destruction
 
InformationLoadModule::InformationLoadModule()
{
    info_load_pif_value = 0.0;
    max_history_size = 120;
}
 
InformationLoadModule::~InformationLoadModule()
{
 
}
 
void InformationLoadModule::clearInformationLoadData() {
    this->info_load_history.clear();
    this->time_history.clear();
}
 
void InformationLoadModule::setInfoLoadPIFValue(double x) {info_load_pif_value = x;}
double InformationLoadModule::getInfoLoadPIFValue() {return info_load_pif_value;}
void InformationLoadModule::setMaxHistorySize(int n) {max_history_size = n;}
int InformationLoadModule::getMaxHistorySize() {return max_history_size;}
void InformationLoadModule::setLowerInfoLoadThreshold(double x) {lower_info_load_threshold = x;}
double InformationLoadModule::getLowerInfoLoadThreshold() {return lower_info_load_threshold;}
void InformationLoadModule::setUpperInfoLoadThreshold(double x) {upper_info_load_threshold = x;}
double InformationLoadModule::getUpperInfoLoadThreshold() {return upper_info_load_threshold;}
 
void InformationLoadModule::addInformationLoadData(double _time, double _load){
    this->time_history.push_back(_time);
    this->info_load_history.push_back(_load);
    while ( this->info_load_history.size() > this->max_history_size) {
        this->info_load_history.pop_front();
        this->time_history.pop_front();
    }
}
double InformationLoadModule::calculateAverageInformationLoadPIFValue() {
    int size = this->time_history.size();
    double delta_time = 0.0;
    double load_sum = 0.0;
    double average_load;
    double new_info_load_pif_value = 0.0;
    std::deque<double>::iterator load_itr;
    if (size > 0) {
        delta_time = this->time_history.at(size-1) - this->time_history.at(0);
    } else {
        delta_time = 0.0;
    }
    for (load_itr = this->info_load_history.begin() ; load_itr != this->info_load_history.end() ; load_itr ++) {
        load_sum += (*load_itr);
    }
    if (delta_time > 0.001) {
        average_load = 60.0 * load_sum/delta_time; // info items per minute
    } else {
        average_load = 0.0;
    }
    if (average_load > upper_info_load_threshold) {
        new_info_load_pif_value = 10.0;
    } else if (average_load < lower_info_load_threshold) {
        new_info_load_pif_value = 0.0;
    } else {
        new_info_load_pif_value = 10.0*(average_load - lower_info_load_threshold)/(upper_info_load_threshold-lower_info_load_threshold);
    }
    // apply lag filter to info load to smooth pif factor
    info_load_pif_value += (new_info_load_pif_value - info_load_pif_value)/10.0;
    //
    // ensure PIF value is in the range of 0.0 - 10.0
    info_load_pif_value = std::max<double>(0.0, info_load_pif_value);
    info_load_pif_value = std::min<double>(10.0,info_load_pif_value);
    return info_load_pif_value;
}
 
void InformationLoadModule::outputInformationLoadModuleLabelToFile(std::string _str, std::ofstream &fout) {
    fout << '\t'<< _str << "Info_Load_PIF_Value";
}
void InformationLoadModule::outputInformationLoadModuleUnitsToFile(std::ofstream &fout) {
    fout << "\t Range:_0-10";
}
 
void InformationLoadModule::copyInformationLoadModule(InformationLoadModule & _ilm){
    this->info_load_pif_value = _ilm.getInfoLoadPIFValue();
    this->max_history_size = _ilm.getMaxHistorySize();
    this->lower_info_load_threshold = _ilm.getLowerInfoLoadThreshold();
    this->upper_info_load_threshold = _ilm.getUpperInfoLoadThreshold();
    for (int i = 0 ; i != _ilm.info_load_history.size() ; i++) {
        this->info_load_history.push_back( _ilm.info_load_history.at(i));
        this->time_history.push_back( _ilm.time_history.at(i));
    }
}
void InformationLoadModule::saveInformationLoadModuleToFile(std::ofstream &fout) {
    fout << "InfoLoadPIF"                  << '\n';
    fout << info_load_pif_value            << ' ' << max_history_size          << ' '
         << lower_info_load_threshold      << ' ' << upper_info_load_threshold << '\n';
    fout << this->info_load_history.size() << '\n';
    for (int i = 0 ; i != this->info_load_history.size() ; i++) {
        fout << this->time_history.at(i) << ' ' << this->info_load_history.at(i) << '\n';
    }
}
void InformationLoadModule::retreiveInformationLoadModuleFromFile(std::ifstream &fin){
    int i, num;
    double x_time, x_info_load;
    std::string str;
    fin >> str;
    fin >> info_load_pif_value       >> max_history_size
        >> lower_info_load_threshold >> upper_info_load_threshold;
    fin >> num;
    for (i = 0 ; i != num ; i++) {
        fin >> x_time >> x_info_load;
        this->time_history.push_back(x_time);
        this->info_load_history.push_back(x_info_load);
    }
}