ManeuverActionUnit.cpp

Go to the documentation of this file.

// ManeuverActionUnit.cpp: implementation of the ManeuverActionUnit class.
//
 
#include "ManeuverActionUnit.h"
#include "Operator.h"
#include "../ControlPanel/ControlPanelControl.h"
#include "../ControlPanel/ControlPanel.h"
#include "../Global/fmodule.h"
#include "../Branch/BranchSystemAction.h"
#include "../Branch/BranchRecord.h"
#include "../ControlPanel/DisplayParameterValue.h"
#include "MentalParameterValue.h"
#include "../Global/SimulationContext.h"
using namespace std;
 
 
// Construction/Destruction
 
ManeuverActionUnit::ManeuverActionUnit()
{
    maneuver_name = "NONE";
    corresponding_interactive_control_name = "NONE";
    LB_interactive_control = 0.0;
    UB_interactive_control = 0.0;
    previous_control_value = 0.0;
    targeted_parameter_name = "NONE";
    LB_target_value = 0.0;
    UB_target_value = 0.0;
    target_value = 0.0;
    targeted_parameter_rate_name = "NONE";
    maneuver_time_interval = 0.0;
    maneuver_total_duration = 0.0;
    previous_maneuver_time = -1.0e6;
    ptr_to_corresponding_indicator = 0;
    ptr_to_corresponding_rate_indicator = 0;
    ptr_to_corresponding_control = 0;
    first_maneuver_time = -1.0e6;
}
 
ManeuverActionUnit::~ManeuverActionUnit()
{
    this->three_by_three_maneuver.clear();
}
void ManeuverActionUnit::setManeuverName(string str){maneuver_name = str;}
void ManeuverActionUnit::setCorrespondingInteractiveControlName(string str){corresponding_interactive_control_name = str;}
void ManeuverActionUnit::setTargetedParameterName(string str){targeted_parameter_name = str;}
void ManeuverActionUnit::setTargetedParameterRateName(string str){targeted_parameter_rate_name = str;}
void ManeuverActionUnit::setLBInteractiveControl(double x){LB_interactive_control = x;}
void ManeuverActionUnit::setUBInteractiveControl(double x){UB_interactive_control = x;}
void ManeuverActionUnit::setPreviousControlValue(double x){previous_control_value = x;}
void ManeuverActionUnit::setLBTargetValue(double x){LB_target_value = x;}
void ManeuverActionUnit::setUBTargetValue(double x){UB_target_value = x;}
void ManeuverActionUnit::setTargetValue(double x){target_value = x;}
void ManeuverActionUnit::setManeuverTimeInterval(double x){maneuver_time_interval = x;}
void ManeuverActionUnit::setManeuverTotalDuration(double x){maneuver_total_duration = x;}
void ManeuverActionUnit::setpreviousManeuverTime(double x){previous_maneuver_time = x;}
void ManeuverActionUnit::setLBChangeRate(double x){LB_change_rate = x;}
void ManeuverActionUnit::setUBChangeRate(double x){UB_change_rate = x;}
void ManeuverActionUnit::setFirstManeuverTime(double x){first_maneuver_time = x;}
string ManeuverActionUnit::getManeuverName(){return maneuver_name;}
string ManeuverActionUnit::getCorrespondingInteractiveControlName(){return corresponding_interactive_control_name;}
string ManeuverActionUnit::getTargetedParameterName(){return targeted_parameter_name;}
string ManeuverActionUnit::getTargetedParameterRateName(){return targeted_parameter_rate_name;}
double ManeuverActionUnit::getLBInteractiveControl(){return LB_interactive_control;}
double ManeuverActionUnit::getUBInteractiveControl(){return UB_interactive_control;}
double ManeuverActionUnit::getPreviousControlValue(){return previous_control_value;}
double ManeuverActionUnit::getLBTargetValue(){return LB_target_value;}
double ManeuverActionUnit::getUBTargetValue(){return UB_target_value;}
double ManeuverActionUnit::getTargetValue(){return target_value;}
double ManeuverActionUnit::getManeuverTimeInterval(){return maneuver_time_interval;}
double ManeuverActionUnit::getManeuverTotalDuration(){return maneuver_total_duration;}
double ManeuverActionUnit::getpreviousManeuverTime(){return previous_maneuver_time;}
double ManeuverActionUnit::getLBChangeRate(){return LB_change_rate;}
double ManeuverActionUnit::getUBChangeRate(){return UB_change_rate;}
double ManeuverActionUnit::getFirstManeuverTime(){return first_maneuver_time;}
 
void ManeuverActionUnit::copyManeuverActionUnit(ManeuverActionUnit & _pmu){
    vector<double>::iterator d_itr;
    maneuver_name = _pmu.getManeuverName();
    corresponding_interactive_control_name = _pmu.getCorrespondingInteractiveControlName();
    targeted_parameter_name = _pmu.getTargetedParameterName();
    targeted_parameter_rate_name = _pmu.getTargetedParameterRateName();
    LB_interactive_control = _pmu.getLBInteractiveControl();
    UB_interactive_control = _pmu.getUBInteractiveControl();
    previous_control_value = _pmu.getPreviousControlValue();
    LB_target_value = _pmu.getLBTargetValue();
    UB_target_value = _pmu.getUBTargetValue();
    target_value = _pmu.getTargetValue();
    maneuver_time_interval = _pmu.getManeuverTimeInterval();
    maneuver_total_duration = _pmu.getManeuverTotalDuration();
    previous_maneuver_time = _pmu.getpreviousManeuverTime();
    LB_change_rate = _pmu.getLBChangeRate();
    UB_change_rate = _pmu.getUBChangeRate();
    first_maneuver_time = _pmu.getFirstManeuverTime();
    StateOfActivation::copyStateOfActivation(_pmu);
    for(d_itr = _pmu.three_by_three_maneuver.begin(); d_itr != _pmu.three_by_three_maneuver.end(); d_itr++){
        this->three_by_three_maneuver.push_back(*d_itr);
    }
}
void ManeuverActionUnit::readInfoFromFile(ifstream &fin){
    string str;
    int i;
    double d1, d2, d3;
    fin >> str >> maneuver_name
        >> str >> corresponding_interactive_control_name >> LB_interactive_control >> UB_interactive_control
        >> str >> targeted_parameter_name
        >> str >> LB_target_value >> target_value >> UB_target_value
        >> str >> targeted_parameter_rate_name
        >> str >> LB_change_rate >> UB_change_rate
        >> str;
    for(i = 0; i < 3; i++){
        fin >> str >> d1 >> d2 >> d3;
        this->three_by_three_maneuver.push_back(d1);
        this->three_by_three_maneuver.push_back(d2);
        this->three_by_three_maneuver.push_back(d3);
    }
    fin >> str >> maneuver_time_interval
        >> str >> maneuver_total_duration;
}
void ManeuverActionUnit::saveManeuverActionUnitToFile(ofstream &fout){
    int i;
    StateOfActivation::saveStateOfActivationToFile(fout);
    fout << maneuver_name << ' '
        << corresponding_interactive_control_name << ' '
        << LB_interactive_control << ' '
        << UB_interactive_control << ' '
        << previous_control_value << ' '
        << targeted_parameter_name << ' '
        << LB_target_value << ' '
        << UB_target_value << ' '
        << target_value << ' '
        << targeted_parameter_rate_name << ' '
        << LB_change_rate << ' '
        << UB_change_rate << ' '
        << maneuver_time_interval << ' '
        << maneuver_total_duration << ' '
        << previous_maneuver_time << ' '
        << first_maneuver_time << ' '
        << this->three_by_three_maneuver.size() << ' ';
    for(i = 0; i < this->three_by_three_maneuver.size(); i++){
        fout << this->three_by_three_maneuver.at(i) << ' ';
    }
    fout << '\n';
}
void ManeuverActionUnit::retrieveManeuverActionUnitFromFile(ifstream &fin){
    int i, num;
    double d_value;
    StateOfActivation::retrieveStateOfActivationFromFile(fin);
    fin >> maneuver_name
        >> corresponding_interactive_control_name
        >> LB_interactive_control
        >> UB_interactive_control
        >> previous_control_value
        >> targeted_parameter_name
        >> LB_target_value
        >> UB_target_value
        >> target_value
        >> targeted_parameter_rate_name
        >> LB_change_rate
        >> UB_change_rate
        >> maneuver_time_interval
        >> maneuver_total_duration
        >> previous_maneuver_time
        >> first_maneuver_time
        >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        this->three_by_three_maneuver.push_back(d_value);
    }
}
void ManeuverActionUnit::executeManeuverControl(Operator &_operator){
    double previous_control_value;
    double current_parameter_value;
    double current_parameter_change_rate;
    double current_control_value;
    double percentage_change_in_control_value;
    BranchSystemAction *bsa_success;
    DisplayParameterValue *dpv_pt, *dpvr_pt;
    //determine the need to maneuver based on the time of previous activity
    if ((r5pars_.timesno - previous_maneuver_time) >= maneuver_time_interval){
        previous_maneuver_time = r5pars_.timesno;
    }
    else{
        return;
    }
//check and assign the pointers pointing to the corresponding parameters
    if(ptr_to_corresponding_indicator == 0){
        ptr_to_corresponding_indicator = (SystemDisplay *) g_sim.Indicator.indicators.getDisplayFromMap(targeted_parameter_name);
    }
    if(ptr_to_corresponding_rate_indicator == 0){
        ptr_to_corresponding_rate_indicator = (SystemDisplay *) g_sim.Indicator.indicators.getDisplayFromMap(targeted_parameter_rate_name);
    }
    if(ptr_to_corresponding_control == 0){
        ptr_to_corresponding_control = (SystemControl *) g_sim.Indicator.controls.getControlFromMap(corresponding_interactive_control_name);
    }
    //pointer search error management is handled in the ControlPanel::indicators and ControlPanel::conntrols.  No need to do  error control here
    if(ptr_to_corresponding_indicator == 0 || ptr_to_corresponding_rate_indicator == 0 || ptr_to_corresponding_control == 0){
        return;
    }
    if(ptr_to_corresponding_control->getFunctionalState() == sim::State::FailedP){
        return;
    }
//set first amneuver time and check total action duration time
    if(first_maneuver_time < 0){
        first_maneuver_time = r5pars_.timesno;
    }
    if((r5pars_.timesno - first_maneuver_time) >= maneuver_total_duration){
        this->setStateOfActivation(sim::State::Done);
        first_maneuver_time = -1.0e6;
        previous_maneuver_time = -1.0e6;
        return;
    }
//perform control: first get change in control rate in percentage
    dpv_pt = (DisplayParameterValue *) ptr_to_corresponding_indicator;
    dpvr_pt = (DisplayParameterValue *) ptr_to_corresponding_rate_indicator;
    previous_control_value = ptr_to_corresponding_control->getControlValue();
    current_parameter_value = dpv_pt->getDisplayedParameterValue();
    current_parameter_change_rate = dpvr_pt->getDisplayedParameterValue();
    //
    if(current_parameter_change_rate < LB_change_rate){
        if(current_parameter_value < LB_target_value){
            percentage_change_in_control_value = this->three_by_three_maneuver.at(0);
        }
        else if (current_parameter_value > UB_target_value){
            percentage_change_in_control_value = this->three_by_three_maneuver.at(2);
        }
        else{
            percentage_change_in_control_value = this->three_by_three_maneuver.at(1);
        }
    }
    else if(current_parameter_change_rate > UB_change_rate){
        if(current_parameter_value < LB_target_value){
            percentage_change_in_control_value = this->three_by_three_maneuver.at(6);
        }
        else if (current_parameter_value > UB_target_value){
            percentage_change_in_control_value = this->three_by_three_maneuver.at(8);
        }
        else{
            percentage_change_in_control_value = this->three_by_three_maneuver.at(7);
        }
    }
    else{
        if(current_parameter_value < LB_target_value){
            percentage_change_in_control_value = this->three_by_three_maneuver.at(3);
        }
        else if (current_parameter_value > UB_target_value){
            percentage_change_in_control_value = this->three_by_three_maneuver.at(5);
        }
        else{
            percentage_change_in_control_value = this->three_by_three_maneuver.at(4);
        }
    }
//calculate final control rate
    if (percentage_change_in_control_value > 1.0){//note at: this time the percentage_change_in_control_value is a positive value
        current_control_value = previous_control_value + (UB_interactive_control - previous_control_value) * percentage_change_in_control_value / 100.0;
        if((UB_interactive_control - current_control_value) < 0.01) {
            current_control_value = UB_interactive_control;
        }
        ptr_to_corresponding_control->setControlValue(current_control_value);
        bsa_success = new BranchSystemAction();
        bsa_success->setDisplayName(this->getCorrespondingInteractiveControlName());
        bsa_success->setControlValue(current_control_value);
        bsa_success->setSenderAndReceiver(_operator.getTypeOfOperator(), sim::Source::Plant);
        bsa_success->setFunctionalState(sim::State::Unknown);
        bsa_success->setTimerAndProbability(0.0, 1.0 - _operator.hfe_bbn.getManeuverActionFailureProbability());
        g_sim.Branch_center.addHWReliabilityBranch(bsa_success);
        //
        if ((current_control_value > (UB_interactive_control + 0.0001)) || 
            (current_control_value < (LB_interactive_control - 0.0001))){
            ofstream fout("err messages.txt", ios::app);
            cout << "ManeuverActionUnit::executeManeuverControl " << this->getManeuverName() << " action: " 
                << this->getCorrespondingInteractiveControlName() << " whose control value: "
                << current_control_value << " is out of bound" << endl;
            fout << r5pars_.timesno << " ManeuverActionUnit::executeManeuverControl " << this->getManeuverName() << " action: " 
                << this->getCorrespondingInteractiveControlName() << " whose control value: "
                << current_control_value << " is out of bound\n";
            fout.close();
        }
    }
    else if (percentage_change_in_control_value < -1.0){//note at: this time the percentage_change_in_control_value is a negative value
        current_control_value = previous_control_value + (previous_control_value - LB_interactive_control) * percentage_change_in_control_value / 100.0;
        if((current_control_value - LB_interactive_control) < 0.01) {
            current_control_value = LB_interactive_control;
        }
        ptr_to_corresponding_control->setControlValue(current_control_value);
        bsa_success = new BranchSystemAction();
        bsa_success->setDisplayName(this->getCorrespondingInteractiveControlName());
        bsa_success->setControlValue(current_control_value);
        bsa_success->setSenderAndReceiver(_operator.getTypeOfOperator(), sim::Source::Plant);
        bsa_success->setFunctionalState(sim::State::Unknown);
        bsa_success->setTimerAndProbability(0.0, 1.0 - _operator.hfe_bbn.getManeuverActionFailureProbability());
        g_sim.Branch_center.addHWReliabilityBranch(bsa_success);
        //
        if ((current_control_value > (UB_interactive_control + 0.0001)) || 
            (current_control_value < (LB_interactive_control - 0.0001))){
            ofstream fout("err messages.txt", ios::app);
            cout << "ManeuverActionUnit::executeManeuverControl " << this->getManeuverName() << " action: " 
                << this->getCorrespondingInteractiveControlName() << " whose control value: "
                << current_control_value << " is out of bound" << endl;
            fout << r5pars_.timesno << " ManeuverActionUnit::executeManeuverControl " << this->getManeuverName() << " action: " 
                << this->getCorrespondingInteractiveControlName() << " whose control value: "
                << current_control_value << " is out of bound\n";
            fout.close();
        }
    }
    else{
        //do nothing
    }
}