DisplayParameterValueRate.cpp

Go to the documentation of this file.

// DisplayParameterValueRate.cpp: implementation of the DisplayParameterValueRate class.
//
 
#include "DisplayParameterValueRate.h"
#include "../Global/TermConversions.h"
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(DisplayParameterValueRate)
using namespace std;
 
// Construction/Destruction
 
DisplayParameterValueRate::DisplayParameterValueRate()
{
    SystemDisplay::setTypeOfDisplay(DisplayType::ParameterTrend);
    rate_of_change = 0.0;
    num_of_item_for_cal_rate = 120;
}
 
DisplayParameterValueRate::~DisplayParameterValueRate()
{
 
}
void DisplayParameterValueRate::readInfoFromFile(ifstream &fin){
    DisplayParameterValue::readInfoFromFile(fin);
}
void DisplayParameterValueRate::readInfoFromFileWithoutDisplayName(ifstream &fin){
    DisplayParameterValue::readInfoFromFileWithoutDisplayName(fin);
}
void DisplayParameterValueRate::copyDisplayParameterValueRate(DisplayParameterValueRate &dpv){
    deque<double>::iterator par_history_itr;
    deque<double>::iterator time_itr;
    for(par_history_itr = dpv.par_history.begin(); par_history_itr != dpv.par_history.end(); par_history_itr++){
        this->par_history.push_back(*par_history_itr);
    }
    for(time_itr = dpv.time.begin(); time_itr != dpv.time.end(); time_itr++){
        this->time.push_back(*time_itr);
    }
    this->copyDisplayParameterValue(dpv);
    rate_of_change = dpv.getRateOfChange();
    num_of_item_for_cal_rate = dpv.getNumOfItemForCalRate();
}
//slope m = (n *Sum(XY) - Sum(X)Sum(Y))/{nSum(x^2) - (Sum(X))^2}
void DisplayParameterValueRate::calculateRateOfChange(){
    double x1, x2, x21, x22, x3, x4;
    x1 = 0.0;
    x21 = 0.0;
    x22 = 0.0;
    x3 = 0.0;
    x4 = 0.0;
    deque<double>::iterator par_history_itr;
    deque<double>::iterator time_itr;
    if(par_history.size() >= num_of_item_for_cal_rate){
        time_itr = time.begin();
        for(par_history_itr = par_history.begin(); par_history_itr != par_history.end(); par_history_itr++){
            x1 += (*par_history_itr) * (*time_itr);
            x21 += (*par_history_itr);
            x22 += (*time_itr);
            x3 += (*time_itr) * (*time_itr);
            time_itr++;
        }
        x1 *= (double) par_history.size();
        x2 = x21 * x22;
        x3 *= (double) par_history.size();
        x4 = x22 * x22;
        if (x3 != x4){
            rate_of_change = (x1 - x2)/(x3 - x4) * 60.0;//per minute
        }
        else{
            rate_of_change = 0.0;
        }
    }
    else{
        rate_of_change = 0.0;
    }
    this->setDisplayedParameterValue(rate_of_change);
};
double DisplayParameterValueRate::getRateOfChange(){return rate_of_change;}
void DisplayParameterValueRate::setRateOfChange(double x){rate_of_change = x;}
int DisplayParameterValueRate::getNumOfItemForCalRate(){return num_of_item_for_cal_rate;}
void DisplayParameterValueRate::setNumOfItemForCalRate(int n){num_of_item_for_cal_rate = n;}
void DisplayParameterValueRate::addAValueIntoParHistory(){
    double displayed_parameter_value, time_x;
    int i, num;
    if (SystemDisplay::getFunctionalState() == sim::State::Succeed){
        displayed_parameter_value = SystemDisplay::getCorrespondingSystemParameterValue();
    }
    else{
        displayed_parameter_value = this->getDisplayedParameterValueWhenFail();
    }
    if(par_history.size() != 0){
        par_history.push_back(displayed_parameter_value);
        time.push_back(r5pars_.timesno);
    }
    else{
        for(i = 0; i < num_of_item_for_cal_rate; i++){
            par_history.push_back(displayed_parameter_value);
            time_x = r5pars_.timesno - num_of_item_for_cal_rate + i + 1.0;
            time.push_back(time_x);
        }
 
    }
    num = (int) par_history.size();
    if(num > num_of_item_for_cal_rate){
        do{
            par_history.pop_front();
            time.pop_front();
            num = num_of_item_for_cal_rate;
        }while(num > num_of_item_for_cal_rate);
    }
}
void DisplayParameterValueRate::clear(){
    par_history.clear();
    time.clear();
}
void DisplayParameterValueRate::saveDisplayParameterValueRateToFile(ofstream &fout){
    int i;
    double rtemp;
    this->saveDisplayParameterValueToFile(fout);
    rtemp = rate_of_change;
    if (rtemp > -1e-30 && rtemp < 1e-30) {
        rtemp = 0.0;
    }
    fout << rtemp << ' ' << num_of_item_for_cal_rate << '\n';
    fout << par_history.size() << '\n';
    for (i = 0; i < par_history.size(); i++){
        rtemp = par_history.at(i);
        if (rtemp > -1e-30 && rtemp < 1e-30) {
            rtemp = 0.0;
        }
        fout << rtemp << ' ';
    }
    fout << '\n';
    fout << time.size() << '\n';
    for (i = 0; i < time.size(); i++){
        fout << time.at(i) << ' ';
    }
    fout << '\n';
}
void DisplayParameterValueRate::retrieveDisplayParameterValueRateFromFile(ifstream &fin){
    int i, num;
    double temp_x;
    this->retrieveDisplayParameterValueFromFile(fin);
    fin >> rate_of_change >> num_of_item_for_cal_rate >> num;
    for(i = 0; i < num; i++){
        fin >> temp_x;
        par_history.push_back(temp_x);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> temp_x;
        time.push_back(temp_x);
    }
}