ControlPanel.cpp

Go to the documentation of this file.

// ControlPanel.cpp: implementation of the ControlPanel class.
//
 
#if defined(_WIN32)
#include <direct.h>
#include <boost/serialization/export.hpp>
#endif
 
#include "ControlPanel.h"
#include "../System/SystemModule.h"
#include "../Scheduler/Scheduler.h"
#include "../Scheduler/CommunicationPlace.h"
#include "../Crew/OperatorDM.h"
#include "../Crew/TimeConstrainedModule.h"
#include "../HWReliability/HWReliabilityModule.h"
#include "../Global/SimulationContext.h"
#ifdef ENABLE_HCL
#include "../../HCL/hcl/HCLEngine.h"
#endif
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(ControlPanel)
using namespace std;
 
 
// Construction/Destruction
 
ControlPanel::ControlPanel() {
  current_time = -1.0;
  total_number_of_activated_alarm = 0;
  total_weight_of_activated_alarm = 0.0;
}
 
ControlPanel::~ControlPanel() {
  this->clearControlPanel();
}
 
void ControlPanel::readInfoFromFile() {
  // Idempotent: the early registration of the shared configuration loads the
  // panel before the procedure book (the procedures parser resolves
  // expectation targets against the panel name maps), and onFirstInit reaches
  // here again on the engine's normal path. The panel layout is immutable
  // configuration; reloading would append a duplicate of every element.
  if (!indicators.parameter_value_array.empty()) return;
  string indicator_file_name;
  indicator_file_name = g_sim.SScheduler.getIndicatorsDirectory();
  indicator_file_name += "ControlPanel.txt";
 
  ifstream fin_ind(indicator_file_name.c_str(), ios::in);
  //read info from hard disk and construct element search maps
  if (!fin_ind.is_open()) {
    cout << "File: " << indicator_file_name << " can not be opened" << endl;
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  File: " << indicator_file_name << " can not be opened\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("File ControlPanel.txt cannot be open.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
  }
//  establish component map
  ControlPanel::indicators.readInfoFromFile(fin_ind);
  ControlPanel::controls.readInfoFromFile(fin_ind);
  ControlPanel::alarms.readInfoFromFile(fin_ind);
  fin_ind.close();
//
}
 
void ControlPanel::initiationForSimulation() {
  //    Initialization of the control panel based on the contents of the RELAP5 and HCL inputs
  ControlPanel::indicators.initiateAllParametersValues();
  ControlPanel::controls.initiateAllControls();
  // ensure alarms are updated correctly during initiation
  this->checkForNewAlarms();
  //
  //ControlPanel::alarms.initiateAllAlarms(indicators);
 
//  Initialize the SPDS:
  //safety_par_display_system.initiationForSimulation();
}
double ControlPanel::getCurrentTime() { return current_time; }
void ControlPanel::setCurrentTime() { current_time = r5pars_.timesno; }
 
//The updateDisplayAndAlarm is called every time step to keep the information up-to-date
//Controls are not updated here since they are updated individually based on demand
//Only the Indicators and Alarms are updated here
//They updating sequence should not be changed: indicator first followed by alarms
void ControlPanel::updateDisplayAndAlarm() {
  ControlPanel::indicators.updateAllDisplayValueAndState();
  ControlPanel::alarms.updateAllDisplayedAlarmState(ControlPanel::indicators);
}
void ControlPanel::updateDisplay() {
  ControlPanel::indicators.updateAllDisplayValueAndState();
}
 
void ControlPanel::checkForNewAlarms() {
  BranchSystemAlarmState *new_alarm;
  vector<unique_ptr<AlarmParameter>>::iterator ap_itr;// alarm_parameter_value_array;
  vector<unique_ptr<AlarmComponent>>::iterator ac_itr; // alarm_component_state_array;
  vector<unique_ptr<AlarmTwoParameterDifference>>::iterator apd_itr; //alarm_value_difference_array;
  int old_state, new_state;
  int n_new_alarm = 0;
  double weight_new_alarm = 0.0;
  bool new_alarm_generated = false;
  bool sequence_should_be_terminated = false;
  string sequence_terminate_alarms;
  string alarm_name, sub_name;
  sequence_terminate_alarms = "Sequence_terminated_by_alarm:_";
//
  for (ap_itr = ControlPanel::alarms.alarm_parameter_value_array.begin();
       ap_itr != ControlPanel::alarms.alarm_parameter_value_array.end(); ap_itr++) {
    old_state = (*ap_itr)->getDisplayedAlarmState();
    new_state = (*ap_itr)->updateDisplayedAlarmState(ControlPanel::indicators);
//      if(old_state == sim::State::Off && new_state == sim::State::On) {
    // any state change is reported, so alarm clearing and reflash are seen too
    if (old_state != new_state) {
      new_alarm = new BranchSystemAlarmState();
      new_alarm->copySystemAlarm(**ap_itr);
      //debug----------
      //if(new_alarm->getAlarmName() == "A_PZR_LoLVL"){
      //    cout << "DBG ControlPanel::checkForNewAlarms" << endl;
      //}
      //-------------
      new_alarm->setSenderAndReceiver(sim::Source::Plant, sim::None);
      g_sim.Branch_center.system_branch.push_back(unique_ptr<BranchSystemAlarmState>(new_alarm));
      n_new_alarm += 1;
      weight_new_alarm += new_alarm->getImportanceOfTheAlarm();
      new_alarm_generated = true;
      alarm_name = new_alarm->getAlarmName();
      if (alarm_name.size() >= 9) {
        sub_name = alarm_name.substr(0, 9);
        if (sub_name == "A_ENDSEQ_") {
          sequence_should_be_terminated = true;
          sequence_terminate_alarms += alarm_name;
          sequence_terminate_alarms += ':';
        }
      }
    }
  }
  for (ac_itr = ControlPanel::alarms.alarm_component_state_array.begin();
       ac_itr != ControlPanel::alarms.alarm_component_state_array.end(); ac_itr++) {
    old_state = (*ac_itr)->getDisplayedAlarmState();
    new_state = (*ac_itr)->updateDisplayedAlarmState(ControlPanel::indicators);
//      if(old_state == sim::State::Off && new_state == sim::State::On) {
    // any state change is reported, so alarm clearing and reflash are seen too
    if (old_state != new_state) {
      new_alarm = new BranchSystemAlarmState();
      new_alarm->copySystemAlarm(**ac_itr);
      new_alarm->setSenderAndReceiver(sim::Source::Plant, sim::None);
      g_sim.Branch_center.system_branch.push_back(unique_ptr<BranchSystemAlarmState>(new_alarm));
      n_new_alarm += 1;
      weight_new_alarm += new_alarm->getImportanceOfTheAlarm();
      new_alarm_generated = true;
      alarm_name = new_alarm->getAlarmName();
      if (alarm_name.size() >= 9) {
        sub_name = alarm_name.substr(0, 9);
        if (sub_name == "A_ENDSEQ_") {
          sequence_should_be_terminated = true;
          sequence_terminate_alarms += alarm_name;
          sequence_terminate_alarms += ':';
        }
      }
    }
  }
  for (apd_itr = ControlPanel::alarms.alarm_value_difference_array.begin();
       apd_itr != ControlPanel::alarms.alarm_value_difference_array.end(); apd_itr++) {
    old_state = (*apd_itr)->getDisplayedAlarmState();
    new_state = (*apd_itr)->updateDisplayedAlarmState(ControlPanel::indicators);
//      if(old_state == sim::State::Off && new_state == sim::State::On) {
    // any state change is reported, so alarm clearing and reflash are seen too
    if (old_state != new_state) {
      new_alarm = new BranchSystemAlarmState();
      new_alarm->copySystemAlarm(**apd_itr);
      new_alarm->setSenderAndReceiver(sim::Source::Plant, sim::None);
      g_sim.Branch_center.system_branch.push_back(unique_ptr<BranchSystemAlarmState>(new_alarm));
      n_new_alarm += 1;
      weight_new_alarm += new_alarm->getImportanceOfTheAlarm();
      new_alarm_generated = true;
      alarm_name = new_alarm->getAlarmName();
      if (alarm_name.size() >= 9) {
        sub_name = alarm_name.substr(0, 9);
        if (sub_name == "A_ENDSEQ_") {
          sequence_should_be_terminated = true;
          sequence_terminate_alarms += alarm_name;
          sequence_terminate_alarms += ':';
        }
      }
    }
  }
  ControlPanel::updateTotalNumberOfActivatedAlarm(n_new_alarm);
  ControlPanel::updateTotalWeightOfActivatedAlarm(weight_new_alarm);
  if (sequence_should_be_terminated) {
    g_sim.SScheduler.setSequenceTerminatedByAlarm(true);
    g_sim.SScheduler.setInfoOfSequenceTerminatedByAlarm(sequence_terminate_alarms);
  }
}
void ControlPanel::updateTotalNumberOfActivatedAlarm(int n) {
  total_number_of_activated_alarm += n;
}
void ControlPanel::updateTotalWeightOfActivatedAlarm(double x) {
  total_weight_of_activated_alarm += x;
}
int ControlPanel::getTotalNumberOfActivatedAlarm() { return total_number_of_activated_alarm; }
double ControlPanel::getTotalWeightOfActivatedAlarm() { return total_weight_of_activated_alarm; }
void ControlPanel::executeValueControl(string _ctrl_name, double _ctrl_value) {
  controls.executeValueControl(_ctrl_name, _ctrl_value);
}
void ControlPanel::executeStateControl(string _ctrl_name, int _ctrl_state) {
  controls.executeStateControl(_ctrl_name, _ctrl_state);
}
void ControlPanel::executeRequestToPlant() {
  SystemControl *_ctrl;//getControlFromMap(string);
  ControlState *_ctrl_state;
  ControlValue *_ctrl_value;
  SystemDisplay *_system_display, *_system_display1, *_system_display2;
  SystemControl *_system_control;
  SystemAlarm *_system_alarm;
  DisplayComponentState *_component_state;
  DisplaySupportSystemState *_support_system_state;
  DisplayParameterValue *_parameter_value;
  DisplayParameterValueRate *_parameter_trend;
  DisplayHeatStructure *_heat_structure; //meash points are the objects stored
  BranchAction *b_action_pt;
  BranchSystemAction *bsa_success, *bsa_fail;
  //TODO:
  BranchSupportSystemAction *bssa_success, *bssa_fail;
 
  double act_probability, control_value;
  bool is_a_maneuver_action = false;
  bool is_FT_action = false;
  string str, sub_action_name;
  //iterators declared as auto in range-based for loops below
//  vector<BranchExpectedParameterTrend *>::iterator parameter_trend_itr;
  int functional_state;
  DisplayType control_type, display_type;
  //crew action to change plant state
  functional_state = sim::State::Succeed;
  for (auto &action_elem : g_sim.Communication_place.action) {
    str = action_elem->getActionName();
    if (str.size() > 9) {
      sub_action_name = str.substr(0, 9);
      if (sub_action_name == "MANEUVER_") {
        is_a_maneuver_action = true;
      }
    }
    if (is_a_maneuver_action && action_elem->getIntendedReceiver()
        == sim::Source::Plant) {//reply to teh sender for the maneuver action has been initiated
      action_elem->setIntendedReceiver(action_elem->getSender());
      action_elem->setSender(sim::Source::Plant);
      action_elem->setProbability(1.0);
    } else if (action_elem->getIntendedReceiver() == sim::Source::Plant) {
      _ctrl = controls.getControlFromMap(action_elem->getActionName());
      if (_ctrl != 0 && (_ctrl->getFunctionalState() == sim::State::Succeed || _ctrl->getFunctionalState() == sim::State::Control)) {
        control_type = _ctrl->getTypeOfControl();
        control_value = action_elem->getControlValue();
        if (control_type == DisplayType::ControlState) {
          _ctrl_state = (ControlState *) _ctrl;
          _ctrl_state->performValueControl(g_sim.Plant, control_value);
        } else {//DisplayType::ControlValue
          _ctrl_value = (ControlValue *) _ctrl;
          _ctrl_value->performControl(g_sim.Plant, control_value);
        }
        action_elem->setIntendedReceiver(action_elem->getSender());
        action_elem->setSender(sim::Source::Plant);
        action_elem->setProbability(1.0);
        action_elem->setPerceivedControlValue(_ctrl->getControlValue());
        action_elem->setControlValue(_ctrl->getControlValue());
      } else if (_ctrl != 0 && _ctrl->getFunctionalState() == sim::State::Failed) {
        _ctrl->setFunctionalState(sim::State::Recovery);
        // calculate recovery probability
        act_probability = _ctrl->calculateProbability();
        _ctrl->setProbability(act_probability);
        //successful recovery
        str = "Successful Recovery (probability = ";
        str += to_string(act_probability);
        str += ")";
        b_action_pt = new BranchAction();
        b_action_pt->copyBranchAction(*action_elem);
        b_action_pt->setDisplayName(b_action_pt->getActionName());
        b_action_pt->setBothTotalTimeRequiredAndRemainingTime(0.0);
        b_action_pt->setActionTime(0.0);
        b_action_pt->setProbability(act_probability);
        b_action_pt->setMessage(str);
        g_sim.Branch_center.addAction(b_action_pt->getSender(), b_action_pt);
        //fail to recover
        str = "Failure of Recovery (probability = ";
        str += to_string(1.0 - act_probability);
        str += ")";
        b_action_pt = new BranchAction();
        b_action_pt->copyBranchAction(*action_elem);
        b_action_pt->setDisplayName("FAIL_RECOVERY");
        b_action_pt->setBothTotalTimeRequiredAndRemainingTime(0.0);
        b_action_pt->setActionTime(0.0);
        b_action_pt->setProbability(1.0 - act_probability);
        b_action_pt->setMessage(str);
        g_sim.Branch_center.addAction(b_action_pt->getSender(), b_action_pt);
      } else if (_ctrl != 0 && _ctrl->getFunctionalState() == sim::State::Recovery) {//fail recovery
        if (action_elem->getDisplayName() == "FAIL_RECOVERY") {
          _ctrl->setFunctionalState(sim::State::FailedP);//permonent failure
        } else {//successful recovery
          _ctrl->setFunctionalState(sim::State::Succeed);
          control_type = _ctrl->getTypeOfControl();
          control_value = action_elem->getControlValue();
          if (control_type == DisplayType::ControlState) {
            _ctrl_state = (ControlState *) _ctrl;
            _ctrl_state->performValueControl(g_sim.Plant, control_value);
          } else {//DisplayType::ControlValue
            _ctrl_value = (ControlValue *) _ctrl;
            _ctrl_value->performControl(g_sim.Plant, control_value);
          }
        }
        action_elem->setIntendedReceiver(action_elem->getSender());
        action_elem->setSender(sim::Source::Plant);
        action_elem->setProbability(1.0);
        action_elem->setPerceivedControlValue(_ctrl->getControlValue());
        action_elem->setControlValue(_ctrl->getControlValue());
      } else if (_ctrl != 0 && _ctrl->getFunctionalState() == sim::State::FailedP) {//hardware permanent failure
        action_elem->setIntendedReceiver(action_elem->getSender());
        action_elem->setSender(sim::Source::Plant);
        action_elem->setProbability(1.0);
      } else {
        ofstream fout("err messages.txt", ios::app);
        cout << "ControlPanel::executeRequestToPlant: Action: " << action_elem->getActionName()
             << " can not be recognized" << endl;
        fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: Action: " << action_elem->getActionName()
             << " can not be recognized\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err1.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      }
    }
  }
  //TODO:
  //check for actions due to hardware value or operator maneuver controls
  for (auto &hw_elem : g_sim.Communication_place.HW_reliability) {
    if (hw_elem->getSender() == sim::Operator::OAT || hw_elem->getSender() == sim::Operator::ODM
        || hw_elem->getSender() == sim::Operator::OCT) {
      is_a_maneuver_action = true;
    } else if (hw_elem->getSender() == sim::Branch::FtPlant) {
      is_FT_action = true;
    } else {
      is_a_maneuver_action = false;
      is_FT_action = false;
    }
 
    if (hw_elem->getFunctionalState() == sim::State::Failed && !is_a_maneuver_action && !is_FT_action) {
      _system_control =
          this->controls.getControlFromMap(hw_elem->getCorrespondingComponentNameOfControl());
      if (_system_control != 0) {
        _system_control->setFunctionalState(sim::State::Failed);
        // apply the failed control value through the panel
        //_system_control->setControlValue(hw_elem->getControlValue());
        this->executeValueControl(hw_elem->getCorrespondingComponentNameOfControl(),
                                  hw_elem->getControlValue());
      } else {
        ofstream fout("err messages.txt", ios::app);
        cout << "ControlPanel::executeRequestToPlant: HW_reliability: "
             << hw_elem->getCorrespondingComponentNameOfControl() << " can not be recognized" << endl;
        fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: HW_reliability: "
             << hw_elem->getCorrespondingComponentNameOfControl() << " can not be recognized\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err2.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      }
    } else if (hw_elem->getFunctionalState() == sim::State::Failed && is_FT_action) {
      string topNodeName = hw_elem->getDisplayName();
      HWReliabilityFTUnit *ft = g_sim.System_reliability.getHWReliabilityFTUnit(topNodeName);
      if (ft != 0) {
#ifdef ENABLE_HCL
        if (ft->getHclEngine()->isFTDefined(hw_elem->getCorrespondingComponentNameOfControl())) {
          ft->getHclEngine()->fixEvent(hw_elem->getCorrespondingComponentNameOfControl(), hw_elem->getControlValue());
          ft->updateFailureProbability();
        } else {
#else
        if (false) {
#endif
          ofstream fout("err messages.txt", ios::app);
          cout << "ControlPanel::executeRequestToPlant: HW_reliability: "
               << hw_elem->getCorrespondingComponentNameOfControl() << " basic node cannot be found in " << hw_elem->getDisplayName()
               << " FT" << endl;
          fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: HW_reliability: "
               << hw_elem->getCorrespondingComponentNameOfControl() << " basic node cannot be found in "<< hw_elem->getDisplayName()
              << " FT" << "\n";
          fout.close();
          r5pars_.sim_err = true;
          g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err2.");
          g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
        }
      } else {
        ofstream fout("err messages.txt", ios::app);
        cout << "ControlPanel::executeRequestToPlant: HW_reliability: "
             << hw_elem->getCorrespondingComponentNameOfControl() << " can not be recognized" << endl;
        fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: HW_reliability: "
             << hw_elem->getCorrespondingComponentNameOfControl() << " can not be recognized\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err2.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      }
    } else if (is_a_maneuver_action) {//humman maneuver actions
      _ctrl = controls.getControlFromMap(hw_elem->getDisplayName());
      functional_state = _ctrl->getFunctionalState();
      if (_ctrl != 0) {//the control is identified
        if (functional_state == sim::State::Succeed) {//component is OK to operate
          control_type = _ctrl->getTypeOfControl();
          control_value = hw_elem->getControlValue();
          if (control_type == DisplayType::ControlState) {
            _ctrl_state = (ControlState *) _ctrl;
            _ctrl_state->performValueControl(g_sim.Plant, control_value);
          } else {//DisplayType::ControlValue
            _ctrl_value = (ControlValue *) _ctrl;
            _ctrl_value->performControl(g_sim.Plant, control_value);
          }
        } else if (functional_state == sim::State::FailedP) {//Component failed permanently
          //do nothing here
        } else {//component failed but recoverable.  Operator's first maneuver action would generate success and failure branches
          if (hw_elem->getFunctionalState()
              == sim::State::Unknown) {//Generate two branches: successful and fail recoveries
            // calculate recovery probability
            act_probability = hw_elem->calculateProbability();
            hw_elem->setProbability(act_probability);
            //
            bsa_success = new BranchSystemAction();
            bsa_success->copyBranchSystemAction(*hw_elem);
            bsa_success->setFunctionalState(sim::State::Succeed);
            //Set the probability of successful recovery
            bsa_success->setTimerAndProbability(0.0, act_probability);
            //
            bsa_fail = new BranchSystemAction();
            bsa_fail->copyBranchSystemAction(*hw_elem);
            bsa_fail->setFunctionalState(sim::State::FailedP);
            //Set the probability of failure recovery
            bsa_fail->setTimerAndProbability(0.0, 1 - act_probability);
            g_sim.Branch_center.addHWReliabilityBranch(bsa_success, bsa_fail);
          } else if (hw_elem->getFunctionalState() == sim::State::Succeed) {//the component is successfully recovered
            _ctrl->setFunctionalState(sim::State::Succeed);
            control_type = _ctrl->getTypeOfControl();
            control_value = hw_elem->getControlValue();
            if (control_type == DisplayType::ControlState) {
              _ctrl_state = (ControlState *) _ctrl;
              _ctrl_state->performValueControl(g_sim.Plant, control_value);
            } else {//DisplayType::ControlValue
              _ctrl_value = (ControlValue *) _ctrl;
              _ctrl_value->performControl(g_sim.Plant, control_value);
            }
          } else if (hw_elem->getFunctionalState()
              == sim::State::FailedP) {//the compoent is recovered with failure: failed permanently
            _ctrl->setFunctionalState(sim::State::FailedP);
          } else {
            ofstream fout("err messages.txt", ios::app);
            cout << "ControlPanel::executeRequestToPlant: HW_reliability: manueuval control 0 "
                 << hw_elem->getDisplayName() << " has unknown functional state" << endl;
            fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: HW_reliability: manueuval control 0 "
                 << hw_elem->getDisplayName() << " has unknown functional state\n";
            fout.close();
            r5pars_.sim_err = true;
            g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err3.");
            g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
          }
        }
      } else {
        ofstream fout("err messages.txt", ios::app);
        cout << "ControlPanel::executeRequestToPlant: HW_reliability: manueuval control "
             << hw_elem->getDisplayName() << " can not be recognized" << endl;
        fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: HW_reliability: manueuval control "
             << hw_elem->getDisplayName() << " can not be recognized\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err3.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      }
    } else {
    }
  }
  //Check requests for state of components
  for (auto &cs_elem : g_sim.Communication_place.component_state) {
    if (cs_elem->getIntendedReceiver() == sim::Source::Plant) {
      _system_display = indicators.getDisplayFromMap(cs_elem->getDisplayName());
      if (_system_display == 0) {
        _system_display = indicators.getDisplayFromMap(cs_elem->getInfoName());
      }
      if (_system_display != 0) {
        display_type = _system_display->getTypeOfDisplay();
        if (display_type == DisplayType::ComponentState) {
          _component_state = (DisplayComponentState *) _system_display;
          cs_elem->setObservedComponentState(_component_state->getDisplayedComponentOperationalState());
          cs_elem->setIntendedReceiver(cs_elem->getSender());
          cs_elem->setSender(sim::Source::Plant);
          cs_elem->setProbability(1.0);
        } else {
          ofstream fout("err messages.txt", ios::app);
          cout << "ControlPanel::executeRequestToPlant: Component State: Incorrect display type " << static_cast<int>(display_type)
               << " with name " << _system_display->getDisplayName()
               << endl;
          fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: Component State: Incorrect display type "
               << static_cast<int>(display_type)
               << " with name " << _system_display->getDisplayName()
               << '\n';
          fout.close();
          r5pars_.sim_err = true;
          g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err3.");
          g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
        }
      } else {
        ofstream fout("err messages.txt", ios::app);
        cout << "ControlPanel::executeRequestToPlant: Component State: "
             << cs_elem->getCorrespondingSystemParameterName() << " can not be recognized" << endl;
        fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: Component State: "
             << cs_elem->getCorrespondingSystemParameterName() << " can not be recognized\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err4.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      }
    }
  }
  //Check requests for state of support systems
  for (auto &ss_elem : g_sim.Communication_place.support_system_state) {
    if (ss_elem->getIntendedReceiver() == sim::Source::Plant) {
      _system_display = indicators.getDisplayFromMap(ss_elem->getDisplayName());
      if (_system_display == 0) {
        _system_display = indicators.getDisplayFromMap(ss_elem->getInfoName());
      }
      if (_system_display != 0) {
        display_type = _system_display->getTypeOfDisplay();
        if (display_type == DisplayType::SupportSystemState) {
          _support_system_state = (DisplaySupportSystemState *) _system_display;
          ss_elem->setObservedSupportSystemState(_support_system_state->getDisplayedSupportSystemOperationalState());
          ss_elem->setIntendedReceiver(ss_elem->getSender());
          ss_elem->setSender(sim::Source::Plant);
          ss_elem->setProbability(1.0);
        } else {
          ofstream fout("err messages.txt", ios::app);
          cout << "ControlPanel::executeRequestToPlant: Support System State: Incorrect display type " << static_cast<int>(display_type)
               << endl;
          fout << r5pars_.timesno
               << "  ControlPanel::executeRequestToPlant: Support System State: Incorrect display type "
               << static_cast<int>(display_type) << '\n';
          fout.close();
          r5pars_.sim_err = true;
          g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err3.");
          g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
        }
      } else {
        ofstream fout("err messages.txt", ios::app);
        cout << "ControlPanel::executeRequestToPlant: Support System State: "
             << ss_elem->getDisplayName() << " can not be recognized" << endl;
        fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: Support System State: "
             << ss_elem->getDisplayName() << " can not be recognized\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err4.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      }
    }
  }
  //Check requests for state of parameters
  for (auto &pv_elem : g_sim.Communication_place.parameter_value) {
    if (pv_elem->getIntendedReceiver() == sim::Source::Plant) {
      _system_display = indicators.getDisplayFromMap(pv_elem->getDisplayName());
      if (_system_display == 0) {
        _system_display = indicators.getDisplayFromMap(pv_elem->getInfoName());
      }
      if (_system_display != 0) {
        display_type = _system_display->getTypeOfDisplay();
        if (display_type == DisplayType::ParameterValue) {
          _parameter_value = (DisplayParameterValue *) _system_display;
          pv_elem->setObservedParameterValue(_parameter_value->getDisplayedParameterValue());
          pv_elem->setIntendedReceiver(pv_elem->getSender());
          pv_elem->setSender(sim::Source::Plant);
          pv_elem->setProbability(1.0);
        } else if (display_type == DisplayType::HeatStructure) {
          _heat_structure = (DisplayHeatStructure *) _system_display;
          pv_elem->setObservedParameterValue(_heat_structure->getDisplayedParameterValue());
          pv_elem->setIntendedReceiver(pv_elem->getSender());
          pv_elem->setSender(sim::Source::Plant);
          pv_elem->setProbability(1.0);
        } else if (display_type == DisplayType::ParameterTrend) {
          _parameter_trend = (DisplayParameterValueRate *) _system_display;
          pv_elem->setObservedParameterValue(_parameter_trend->getRateOfChange());
          pv_elem->setIntendedReceiver(pv_elem->getSender());
          pv_elem->setSender(sim::Source::Plant);
          pv_elem->setProbability(1.0);
        } else {
          ofstream fout("err messages.txt", ios::app);
          cout << "ControlPanel::executeRequestToPlant: Parameter Value type: " << static_cast<int>(display_type)
               << " can not be recognized" << endl;
          fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: Parameter Value type: " << static_cast<int>(display_type)
               << " can not be recognized\n";
          fout.close();
          r5pars_.sim_err = true;
          g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err5.");
          g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
        }
      } else {
        ofstream fout("err messages.txt", ios::app);
        cout << "ControlPanel::executeRequestToPlant: Parameter Value: neither "
             << pv_elem->getDisplayName() << " nor "
             << pv_elem->getInfoName() << " can not be recognized" << endl;
        fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: Parameter Value: neither "
             << pv_elem->getDisplayName() << " nor "
             << pv_elem->getInfoName() << " can not be recognized\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err6.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      }
    }
  }
  // execute requests for parameter differences
  for (auto &pd_elem : g_sim.Communication_place.parameter_difference) {
    if (pd_elem->getIntendedReceiver() == sim::Source::Plant) {
      // find first difference parameter on the control panel
      _system_display1 =
          indicators.getDisplayFromMap(pd_elem->first_mental_parameter.getDisplayName());
      if (_system_display1 == 0) {
        _system_display1 = indicators.getDisplayFromMap(pd_elem->first_indicator.getInfoName());
      }
      if (_system_display1 != 0) {
        display_type = _system_display1->getTypeOfDisplay();
        if (display_type == DisplayType::ParameterValue) {
          _parameter_value = (DisplayParameterValue *) _system_display1;
          pd_elem->first_mental_parameter.setObservedParameterValue(_parameter_value->getDisplayedParameterValue());
        } else if (display_type == DisplayType::ParameterTrend) {
          _parameter_trend = (DisplayParameterValueRate *) _system_display1;
          pd_elem->first_mental_parameter.setObservedParameterValue(_parameter_trend->getRateOfChange());
        } else {
          ofstream fout("err messages.txt", ios::app);
          cout << "ControlPanel::executeRequestToPlant: Parameter Difference type: " << static_cast<int>(display_type)
               << " can not be recognized" << endl;
          fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: Parameter Difference type: "
               << static_cast<int>(display_type) << " can not be recognized\n";
          fout.close();
          r5pars_.sim_err = true;
          g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err5.");
          g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
        }
      } else {
        ofstream fout("err messages.txt", ios::app);
        cout << "ControlPanel::executeRequestToPlant: Parameter Difference: neither "
             << pd_elem->first_mental_parameter.getDisplayName() << " nor "
             << pd_elem->first_indicator.getInfoName() << " can be recognized" << endl;
        fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: Parameter Difference: neither "
             << pd_elem->first_mental_parameter.getDisplayName() << " nor "
             << pd_elem->first_indicator.getInfoName() << " can be recognized\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err6.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      }
      //
      //find second difference parameter on the control panel
      _system_display2 =
          indicators.getDisplayFromMap(pd_elem->second_mental_parameter.getDisplayName());
      if (_system_display2 == 0) {
        _system_display2 = indicators.getDisplayFromMap(pd_elem->second_indicator.getInfoName());
        pd_elem->second_mental_parameter.copyDisplayElement((DisplayElement &) _system_display2);
      }
      if (_system_display2 != 0) {
        display_type = _system_display2->getTypeOfDisplay();
        if (display_type == DisplayType::ParameterValue) {
          _parameter_value = (DisplayParameterValue *) _system_display2;
          pd_elem->second_mental_parameter.setObservedParameterValue(_parameter_value->getDisplayedParameterValue());
        } else if (display_type == DisplayType::ParameterTrend) {
          _parameter_trend = (DisplayParameterValueRate *) _system_display2;
          pd_elem->second_mental_parameter.setObservedParameterValue(_parameter_trend->getRateOfChange());
        } else {
          ofstream fout("err messages.txt", ios::app);
          cout << "ControlPanel::executeRequestToPlant: Parameter Difference type: " << static_cast<int>(display_type)
               << " can not be recognized" << endl;
          fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: Parameter Difference type: "
               << static_cast<int>(display_type) << " can not be recognized\n";
          fout.close();
          r5pars_.sim_err = true;
          g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err5.");
          g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
        }
      } else {
        ofstream fout("err messages.txt", ios::app);
        cout << "ControlPanel::executeRequestToPlant: Parameter Difference: neither "
             << pd_elem->second_mental_parameter.getDisplayName() << " nor "
             << pd_elem->second_indicator.getInfoName() << " can be recognized" << endl;
        fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: Parameter Difference: neither "
             << pd_elem->second_mental_parameter.getDisplayName() << " nor "
             << pd_elem->second_indicator.getInfoName() << " can be recognized\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err6.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      }
      if (_system_display1 != 0 && _system_display2 != 0) {
        pd_elem->setIntendedReceiver(pd_elem->getSender());
        pd_elem->setSender(sim::Source::Plant);
        pd_elem->setProbability(1.0);
      }
    }
  }
 
  //
  //Check request for states of alarms
  for (auto &as_elem : g_sim.Communication_place.alarm_state) {
    if (as_elem->getIntendedReceiver() == sim::Source::Plant) {
      _system_alarm = alarms.getAlarmFromMap(as_elem->getAlarmName());
      if (_system_alarm == 0) {
        _system_alarm = alarms.getAlarmFromMap(as_elem->getInfoName());
      }
      if (_system_alarm != 0) {
        as_elem->setObservedAlarmState(_system_alarm->getDisplayedAlarmState());
        as_elem->setIntendedReceiver(as_elem->getSender());
        as_elem->setSender(sim::Source::Plant);
        as_elem->setProbability(1.0);
      } else {
        ofstream fout("err messages.txt", ios::app);
        cout << "ControlPanel::executeRequestToPlant: Alarm_state: neither " << as_elem->getAlarmName()
             << " nor "
             << as_elem->getInfoName() << " can not be recognized" << endl;
        fout << r5pars_.timesno << "  ControlPanel::executeRequestToPlant: Parameter Value: neither "
             << as_elem->getAlarmName() << " nor "
             << as_elem->getInfoName() << " can not be recognized\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ControlPanel::executeRequestToPlant err7.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      }
    }
  }
}
void ControlPanel::oneThroughProcess() {
  this->updateDisplay();
  this->checkForNewAlarms();
  //this->safety_par_display_system.updateAllSPDSValueAndRate();
  this->executeRequestToPlant();
}
void ControlPanel::seedFromMaster(const ControlPanel& master) {
  // State overlay: rebuild layout/definitions from the process-local master
  // before the state stream is applied. The copy helpers append, so clear
  // every element container (and the raw-pointer maps they rebuild) first.
  alarms.alarm_parameter_value_array.clear();
  alarms.alarm_component_state_array.clear();
  alarms.alarm_value_difference_array.clear();
  alarms.alarm_map.clear();
  indicators.component_state_array.clear();
  indicators.support_systems_state_array.clear();
  indicators.parameter_value_array.clear();
  indicators.heat_structure_array.clear();
  indicators.parameter_trend_array.clear();
  indicators.display_map.clear();
  controls.control_state_array.clear();
  controls.control_value_array.clear();
  controls.control_map.clear();
  copyControlPanel(const_cast<ControlPanel&>(master));
}
void ControlPanel::copyControlPanel(ControlPanel &_cp) {
  alarms.copyControlPanelAlarm(_cp.alarms);
  indicators.copyControlPanelDisplay(_cp.indicators);
  controls.copyControlPanelControl(_cp.controls);
  //safety_par_display_system.copySPDS(_cp.safety_par_display_system);
  current_time = _cp.getCurrentTime();
  total_number_of_activated_alarm = _cp.getTotalNumberOfActivatedAlarm();
  total_weight_of_activated_alarm = _cp.getTotalWeightOfActivatedAlarm();
}
void ControlPanel::copyControlPanelForRestart(ControlPanel &_cp) {
  this->copyControlPanel(_cp);
};
void ControlPanel::clearControlPanel() {
  alarms.clearControlPanelAlarm();
  indicators.clearControlPanelDisplay();;
  controls.clearControlPanelControl();
  //safety_par_display_system.clearSPDS();
  current_time = -1.0;
  total_number_of_activated_alarm = 0;
  total_weight_of_activated_alarm = 0.0;
}
void ControlPanel::clearForRestart() {
  this->clearControlPanel();
}
void ControlPanel::saveControlPanelToFile(ofstream &fout) {
  fout << "ControlPanel\n" << current_time << ' '
       << total_number_of_activated_alarm << ' '
       << total_weight_of_activated_alarm << '\n';
  alarms.saveControlPanelAlarmToFile(fout);
  indicators.saveControlPanelDisplayToFile(fout);
  controls.saveControlPanelControlToFile(fout);
  //safety_par_display_system.saveSPDSToFile(fout);
}
void ControlPanel::retrieveControlPanelFromFile(ifstream &fin) {
  string str;
  fin >> str;
  if (str != "ControlPanel") {
    ofstream fout("err messages.txt", ios::app);
    cout << "ControlPanel::retrieveControlPanelFromFile File retrieval error in previous function" << endl;
    fout << r5pars_.timesno
         << "  ControlPanel::retrieveControlPanelFromFile File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ControlPanel::retrieveSystemModuleFromFile Prior err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
 
  fin >> current_time
      >> total_number_of_activated_alarm
      >> total_weight_of_activated_alarm;
  alarms.retrieveControlPanelAlarmFromFile(fin);
  indicators.retrieveControlPanelDisplayFromFile(fin);
  controls.retrieveControlPanelControlFromFile(fin);
  //safety_par_display_system.retrieveSPDSFromFile(fin);
}