SPDSUnit.cpp

Go to the documentation of this file.

// SPDSUnit.cpp: implementation of the SPDSUnit class.
//
 
#include "SPDSUnit.h"
#include "../ControlPanel/ControlPanel.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(SPDSUnit)
using namespace std;
 
 
// Construction/Destruction
 
SPDSUnit::SPDSUnit()
{
    LL_threshold = 0.0;
    L_threshold = 0.0;
    H_threshold = 0.0;
    HH_threshold = 0.0; 
    SPDS_unit_weight = 0.0;
    SPDS_unit_value = 0.0;
    SPDS_unit_name = "NONE";
    corresponding_indicator_name = "NONE";
    ptr_to_corresponding_indicator = 0;
}
 
SPDSUnit::~SPDSUnit()
{
 
}
double SPDSUnit::getLLThreshold(){return LL_threshold;}
double SPDSUnit::getLThreshold(){return L_threshold;}
double SPDSUnit::getHHThreshold(){return HH_threshold;}
double SPDSUnit::getHThreshold(){return H_threshold;}
double SPDSUnit::getSPDSUnitWeight(){return SPDS_unit_weight;}
void SPDSUnit::setLLThreshold(double x){LL_threshold = x;}
void SPDSUnit::setLThreshold(double x){L_threshold = x;}
void SPDSUnit::setHThreshold(double x){H_threshold = x;}
void SPDSUnit::setHHThreshold(double x){HH_threshold = x;}
void SPDSUnit::setSPDSUnitWeight(double x){SPDS_unit_weight = x;}
double SPDSUnit::getSPDSUnitValue(){return SPDS_unit_value;}
 
void SPDSUnit::readInfoFromFile(ifstream &fin){
    fin >>  SPDS_unit_name >> corresponding_indicator_name 
        >> LL_threshold >> L_threshold >> H_threshold >> HH_threshold >> SPDS_unit_weight;
}
void SPDSUnit::calculateSPDSUnitValue(InfoChunk * _perceived_info_ptr){
    double current_value;
    //get value
    //DisplayParameterValue *dpv_ptr;
    MentalParameterValue *mpv_ptr = 0;
    //SystemDisplay *d_element;
    mpv_ptr = (*_perceived_info_ptr).checkExistanceOfPerceivedParameterValue(this->getCorrespondingIndicatorName());
    if (mpv_ptr != 0) {
        current_value = (*mpv_ptr).getObservedParameterValue();
//  d_element = 0;
//  if(this->getPtrToCorrespondingIndicator() == 0){
//      this->setPtrToCorrespondingIndicator((SystemDisplay *) Indicator.indicators.getDisplayFromMap(this->getCorrespondingIndicatorName()));
//  }
//  if (this->getPtrToCorrespondingIndicator() != 0){
//      dpv_ptr = (DisplayParameterValue *) this->getPtrToCorrespondingIndicator();
//      current_value = dpv_ptr->getDisplayedParameterValue();
//  }
//  else{
//      cout << "SPDSUnit::calculateSPDSUnitValue could not find SPDS corresponding parameter " << this->getCorrespondingIndicatorName() << endl;
//      ofstream fout("err messages.txt", ios::app);
//      fout << r5pars_.timesno << "  SPDSUnit::calculateSPDSUnitValue could not find SPDS corresponding parameter " << this->getCorrespondingIndicatorName() << '\n';
//      fout.close();
//      r5pars_.sim_err = true;
//      Branch_center.setTempESMessage("ProcedureStepUnit::saveProcedureStepUnitNonResponseActionToFile err.");
//      Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
//  }
        if(current_value < LL_threshold || current_value > HH_threshold){
            SPDS_unit_value = 10.0;
        }
        else if((current_value > L_threshold) && (current_value < H_threshold)){
            SPDS_unit_value = 0.0;
        }
        else if (current_value <= L_threshold){
            SPDS_unit_value = 10.0 * (L_threshold - current_value)/(L_threshold - LL_threshold);
        }
        else{
            SPDS_unit_value = 10.0 * (current_value - H_threshold)/(HH_threshold - H_threshold);
        }
    }
    else {
        SPDS_unit_value = 0.0;   // if no information perceived, set SPDS value to 0.0
    }
}
void SPDSUnit::copySPDSUnit(SPDSUnit &_spds){
    LL_threshold = _spds.getLLThreshold();
    L_threshold = _spds.getLThreshold();
    H_threshold = _spds.getHThreshold();
    HH_threshold = _spds.getHHThreshold(); 
    SPDS_unit_weight = _spds.getSPDSUnitWeight();
    SPDS_unit_value = _spds.getSPDSUnitValue();
    SPDS_unit_name = _spds.getSPDSUnitName();
    corresponding_indicator_name = _spds.getCorrespondingIndicatorName();
 
}
void SPDSUnit::setCorrespondingIndicatorName(string str){corresponding_indicator_name = str;}
string SPDSUnit::getCorrespondingIndicatorName(){return corresponding_indicator_name;}
void SPDSUnit::setSPDSUnitName(string str){SPDS_unit_name = str;}
string SPDSUnit::getSPDSUnitName(){return SPDS_unit_name;}
SystemDisplay *SPDSUnit::getPtrToCorrespondingIndicator(){return ptr_to_corresponding_indicator;}
void SPDSUnit::setPtrToCorrespondingIndicator(SystemDisplay* _display_element){
    ptr_to_corresponding_indicator = _display_element;
}
 
void SPDSUnit::saveSPDSUnitToFile(ofstream &fout){
    fout << LL_threshold << ' '
        << L_threshold << ' '
        << H_threshold << ' '
        << HH_threshold << ' '
        << SPDS_unit_weight << ' '
        << SPDS_unit_value << ' '
        << SPDS_unit_name << ' '
        << corresponding_indicator_name << '\n';
}
void SPDSUnit::retrieveSPDSUnitFromFile(ifstream &fin){
    fin >> LL_threshold 
        >> L_threshold 
        >> H_threshold 
        >> HH_threshold 
        >> SPDS_unit_weight 
        >> SPDS_unit_value 
        >> SPDS_unit_name 
        >> corresponding_indicator_name;
        ptr_to_corresponding_indicator = 0;
}