KBExpectedParameterValueUnit.cpp

Go to the documentation of this file.

// KBExpectedParameterValueUnit.cpp: implementation of the KBExpectedParameterValueUnit class.
//
 
#include "KBExpectedParameterValueUnit.h"
#include "../Branch/BranchRecord.h"
#include "../CalculationAid/CalculationAid.h" //Y.L.
#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(KBExpectedParameterValueUnit)
using namespace std;
 
 
// Construction/Destruction
 
KBExpectedParameterValueUnit::KBExpectedParameterValueUnit()
{
    this->setTypeOfExpectation(sim::Comm::ParameterValue);
    logical_relation = sim::None;
    expected_value1 = 0.0;
    expected_value2 = 0.0;
}
 
KBExpectedParameterValueUnit::~KBExpectedParameterValueUnit()
{
 
}
void KBExpectedParameterValueUnit::setLogicalRelation(int n){logical_relation = n;}
void KBExpectedParameterValueUnit::setExpectedValue1(double x){expected_value1 = x;}
void KBExpectedParameterValueUnit::setExpectedValue2(double x){expected_value2 = x;}
void KBExpectedParameterValueUnit::readInfoFromFile(ifstream &fin){
    KBElement::readInfoFromFile(fin);
    //each expected value is either a number or "ModeV <polynomial name>" (value taken from a polynomial curve)
    string str1, str2;
    fin >> logical_relation;
    fin >> str1;
    if (str1=="ModeV"){
        value1_mode = 1;
        fin >> value1_poly_name;
    }
    else
    {
        value1_mode = 0;
        expected_value1 = atof(str1.c_str());
    }
    fin >> str2;
    if (str2 == "ModeV"){
        value2_mode = 1;
        fin >> value2_poly_name;
    }
    else{
        value2_mode = 0;
        expected_value2  = atof(str2.c_str());
    }
    poly1_pt = 0;
    poly2_pt = 0;
}
int KBExpectedParameterValueUnit::getLogicalRelation(){return logical_relation;}
double KBExpectedParameterValueUnit::getExpectedValue1(){return expected_value1;}
double KBExpectedParameterValueUnit::getExpectedValue2(){return expected_value2;}
int KBExpectedParameterValueUnit::checkForMatch(string _par_name, double _par_value, int _operator){
    string str = KBElement::getInfoName();
    int n_return = 0;
    bool found = true;
    BiResult BiResult1, BiResult2;
    if(_par_name.compare(KBElement::getInfoName()) == 0){
        //polynomial mode: refresh the expected values from their curves
        if (value1_mode == 1)
        {
            if (poly1_pt == 0){ //Problem is here
                poly1_pt = g_sim.All_polynomial.checkExistanceOfPolynomial(value1_poly_name);}
            BiResult1 = poly1_pt->GetCurveValue(_operator);
            if (BiResult1.bool_result == false){
                found = false;}
            else{
                expected_value1 = BiResult1.float_result;
            }
        }
        if (value2_mode == 1)
        {
            if (poly2_pt == 0){
                poly2_pt = g_sim.All_polynomial.checkExistanceOfPolynomial(value2_poly_name);}
            BiResult2 = poly2_pt->GetCurveValue(_operator);
            if (BiResult2.bool_result == false){
                found = false;}
            else{expected_value2 = BiResult2.float_result;}
        }
        if (found == true)
        {
        switch(logical_relation){
        case sim::Compare::GT:
            if(_par_value > expected_value1){
                n_return = ExpectationElement::updateExpectation(sim::State::Succeed);
            }
            else{
                n_return = ExpectationElement::updateExpectation(sim::State::Failed);
            }
            break;
        case sim::Compare::GE:
            if(_par_value >= expected_value1){
                n_return = ExpectationElement::updateExpectation(sim::State::Succeed);
            }
            else{
                n_return = ExpectationElement::updateExpectation(sim::State::Failed);
            }
            break;
        case sim::Compare::EQ:
            if(_par_value == expected_value1){
                n_return = ExpectationElement::updateExpectation(sim::State::Succeed);
            }
            else{
                n_return = ExpectationElement::updateExpectation(sim::State::Failed);
            }
            break;
        case sim::Compare::LE:
            if(_par_value <= expected_value1){
                n_return = ExpectationElement::updateExpectation(sim::State::Succeed);
            }
            else{
                n_return = ExpectationElement::updateExpectation(sim::State::Failed);
            }
            break;
        case sim::Compare::LT:
            if(_par_value < expected_value1){
                n_return = ExpectationElement::updateExpectation(sim::State::Succeed);
            }
            else{
                n_return = ExpectationElement::updateExpectation(sim::State::Failed);
            }
            break;
        case sim::Compare::Between:
            if(_par_value >= expected_value1 && _par_value <= expected_value2){
                n_return = ExpectationElement::updateExpectation(sim::State::Succeed);
            }
            else{
                n_return = ExpectationElement::updateExpectation(sim::State::Failed);
            }
            break;
        default:
            ofstream fout("err messages.txt", ios::app);
            cout << "KBExpectedParameterTrendUnit::checkForMatch par_name: " << _par_name << " whose logical relation: " << logical_relation << " can not be recognized." << endl;
            fout << r5pars_.timesno << "  KBExpectedParameterTrendUnit::checkForMatch par_name: " << _par_name << " whose logical relation: " << logical_relation << " can not be recognized.\n";
            fout.close();
            r5pars_.sim_err = true;
            g_sim.Branch_center.setTempESMessage("KBExpectedParameterValueUnit::checkForMatch err.");
            g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
            break;
        }
        }
        else{n_return = 0;}
    }
    else{
        n_return = 0;
    }
    return n_return;
}
 
void KBExpectedParameterValueUnit::copyKBExpectedParameterValueUnit(KBExpectedParameterValueUnit &_epp){
    KBElement::copyKBElement((KBElement &) _epp);
    ExpectationElement::copyExpectationElement((ExpectationElement &) _epp);
    logical_relation = _epp.getLogicalRelation();
    expected_value1 = _epp.getExpectedValue1();
    expected_value2 = _epp.getExpectedValue2();
    value1_mode = _epp.value1_mode;
    value2_mode = _epp.value2_mode;
    value1_poly_name = _epp.value1_poly_name;
    value2_poly_name = _epp.value2_poly_name;
    poly1_pt = 0;
    poly2_pt = 0;
}
void KBExpectedParameterValueUnit::saveKBExpectedParameterValueUnitToFile(ofstream &fout){
    fout << "KBExpectedParameterValueUnit " << logical_relation << ' ' << expected_value1 << ' ' << expected_value2 << '\n';
    this->saveExpectationElementToFile(fout);
    this->saveKBElementToFile(fout);
}
void KBExpectedParameterValueUnit::retrieveKBExpectedParameterValueUnitFromFile(ifstream &fin){
    string str;
    fin >> str >> logical_relation >> expected_value1 >> expected_value2;
        if (str != "KBExpectedParameterValueUnit"){
        ofstream fout("err messages.txt", ios::app);
        cout << "KBExpectedParameterValueUnit::retrieveKBExpectedParameterValueUnitFromFile in previous function" << endl;
        fout << r5pars_.timesno << "  KBExpectedParameterValueUnit::retrieveKBExpectedParameterValueUnitFromFile in previous function\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("KBExpectedParameterTrendUnit::retrieveKBExpectedParameterTrendUnitFromFile Prior err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
        return;
    }
    this->retrieveExpectationElementFromFile(fin);
    this->retrieveKBElementFromFile(fin);
}