Operator.h

Go to the documentation of this file.

 
 
#include <iostream>
#include <type_traits>
#include <typeinfo>
#pragma once
 
#include "KB.h"
#include "InfoChunk.h"
#include "ShortTermMemory.h"
#include "EventSymptomMatrix.h"
#include <boost/serialization/export.hpp>
//#include "PIFRelap.h"
#include "KBScannedParameters.h"
#include "ManeuverAction.h"
#include "SPDS.h"
#include "TimeConstrainedModule.h"
#include "InformationLoadModule.h"
#include "DiagnosisActionModule.h"
 
#include "../Branch/BranchExpectedParameterValue.h"
#include "../Branch/BranchExpectedComponentState.h"
#include "../Branch/BranchExpectedAlarmState.h"
#include "../ReasonMachine/ReasonMachine.h" // Added by ClassView
#include "../ReasonMachine/RMSerialization.h"
#include "HumanFailureEventsBBN.h"
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/unique_ptr.hpp>
#include <fstream>
#include <sstream>
#include <string>
 
class Operator {
 public:
  void PrintMessage(std::string);
  void ActiveFetchAlarmStateInfo(std::string, int);
  void ActiveFetchComponentStateInfo(std::string, int);
  void ActiveFetchSupportSystemStateInfo(std::string, int);
  std::unique_ptr<ReasonMachine> m_RM;
  void ActiveFetchParameterValueInfo(std::string, int);
  Operator();
  virtual ~Operator();
  void setTypeOfOperator(int);
  int getTypeOfOperator();
  void setMentalProcedurePriorityThreshold(int);
  int getMentalProcedurePriorityThreshold();
  void biasFilter();
  void quantificationFilter();
  void initiationForSimulation();
  void seedKnowledgeBaseFromMaster();  // copy the per-role KB master before the state overlay is applied
  void seedDiagnosisMatrixFromMaster();  // same, for the event-symptom matrix
  void setPauseActivity(bool);
  bool getPauseActivity();
  void setNewBranchGenerated(bool);
  bool getNewBranchGenerated();
  void setPauseMentalProcedure(bool);
  bool getPauseMentalProcedure();
  void setAbnormalSignalPerceived(bool);
  bool getAbnormalSignalPerceived();
  void setBlockTroubleshooting(bool);
  bool getBlockTroubleshooting();
  void setBlockProcedureUse(bool);
  bool getBlockProcedureUse();
  void setAbnormalSignalThreshold(double);
  double getAbnormalSignalThreshold();
  void setSkipProcedureStep(bool);
  bool getSkipProcedureStep();
  void setSkipInstinctiveResponseStep(bool);
  bool getSkipInstinctiveResponseStep();
  void setScanQueueLimit(int);
  int getScanQueueLimit();
  void copyOperatorToRestartInfo(Operator &);
  void copyOperatorFromRestartInfo(Operator &);
  void copyOperatorFromRestartInfoMultiProcessor(Operator &);
  void clearOperatorForRestart();
  void clearOperatorFromRestartInfo();
  void clearOperatorFinal();
  void clearOperatorFromRestartNodeInfoMultiProcessors();
  void setThresholdValueForHWKBConfidence(double);
  double getThresholdValueForHWKBConfidence();
  void setSkipActionThreshold(double);
  double getSkipActionThreshold();
  void setSkipNonResponseThreshold(double);
  double getSkipNonResponseThreshold();
  void setNominalCommunicationTime(double);
  double getNominalCommunicationTime();
  void setTroubleshootingProbability(double);
  double getTroubleshootingProbability();
  void setProcedureUseProbability(double);
  double getProcedureUseProbability();
  void setActionTimeMultiplier(double);
  double getActionTimeMultiplier();
  void setInfoGatherModeBranchGenerated(bool);
  bool getInfoGatherModeBranchGenerated();
  void setUseOfOldInfoProbability(double);
  double getUseOfOldInfoProbabiility();
  int generateInfoGatherModeBranch();
  bool checkAndActivateHWKB();
  void saveOperatorToFile(std::ofstream &);
  void retrieveOperatorFromFile(std::ifstream &);
  void checkCompletenessOfSystemDecomposition(int);
  bool performAMentalProcedure(int, std::string, std::string);
  bool performReasoningStrategy();
  void checkAndExecuteManeuverAction();
  void checkAndResetProcedureStep(BranchProcedureStep *);
  void interruptAllMentalProcedures();
  void interruptLowPriorityMentalProcedures();
  double checkItemRelevanceToCurrentDiagnosis(std::string);
  void updateEvidenceForAllPSFs();
  ShortTermMemory memory;
  KB knowledge_base;
  KBScannedParameters scanned_indicators;
  EventSymptomMatrix diagnosis_matrix;
  //PIFRelap Relap_PIFs;
  SPDS safety_parameters;
  TimeConstrainedModule time_constrained_load;
  InformationLoadModule information_load;
  DiagnosisActionModule event_actions;
  ManeuverAction maneuver_action;
  HumanFailureEventsBBN hfe_bbn;
 
    // Grant serialization access
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
//     std::cout << "Serializing class: " << typeid(*this).name() << std::endl;
        ar & type_of_operator;
        ar & mental_procedure_priority_threshold;
        ar & scan_queue_limit;
        ar & pause_activity;
        ar & pause_mental_procedure;
        ar & skip_procedure_step;
        ar & skip_instinctive_response_step;
        ar & abnormal_signal_perceived;
        ar & block_troubleshooting;
        ar & block_procedure_use;
        ar & new_branch_generated;
        ar & abnormal_signal_threshold;
        ar & threshold_value_for_HWKB_confidence;
        ar & action_time_multiplier;
        ar & skip_action_threshold;
        ar & skip_non_response_threshold;
        ar & troubleshooting_probability;
        ar & procedure_use_probability;
        ar & nominal_communication_time;
        ar & info_gather_mode_branch_generated;
        ar & use_of_old_info_probability;
        // Serialize complex types
        ar & memory;
        // The KB travels state-only on binary archives. type_of_operator,
        // deserialized above, selects the per-role master to seed from.
        if constexpr (std::is_same_v<Archive, boost::archive::binary_oarchive>) {
            knowledge_base.state_save(ar);
        } else if constexpr (std::is_same_v<Archive, boost::archive::binary_iarchive>) {
            seedKnowledgeBaseFromMaster();
            knowledge_base.state_load(ar);
        } else {
            ar & knowledge_base;
        }
        ar & scanned_indicators;
        // The event-symptom matrix travels state-only on binary archives
        // (confidences); its structure is re-seeded from the per-role master.
        if constexpr (std::is_same_v<Archive, boost::archive::binary_oarchive>) {
            diagnosis_matrix.state_save(ar);
        } else if constexpr (std::is_same_v<Archive, boost::archive::binary_iarchive>) {
            seedDiagnosisMatrixFromMaster();
            diagnosis_matrix.state_load(ar);
        } else {
            ar & diagnosis_matrix;
        }
        ar & safety_parameters;
        ar & time_constrained_load;
        ar & information_load;
        ar & event_actions;
        ar & maneuver_action;
        ar & hfe_bbn;
        // Size gauge: prints the serialized byte count of each member of the
        // operator snapshot to stderr. Enabled by setting the environment
        // variable ADSIDAC_OPERATOR_PROFILE (binary saves only).
        if constexpr (std::is_same_v<Archive, boost::archive::binary_oarchive>) {
            static const bool op_prof = getenv("ADSIDAC_OPERATOR_PROFILE") != nullptr;
            if (op_prof) {
                auto blob_bytes = [](const auto& obj) {
                    std::ostringstream oss(std::ios::binary);
                    boost::archive::binary_oarchive oa(oss);
                    oa << obj;
                    return oss.str().size();
                };
                std::ostringstream kb_oss(std::ios::binary);
                { boost::archive::binary_oarchive kb_oa(kb_oss); knowledge_base.state_save(kb_oa); }
                size_t rm_bytes = 0;
                if (m_RM != nullptr) {
                    std::ostringstream rm_oss(std::ios::binary);
                    boost::archive::binary_oarchive rm_oa(rm_oss);
                    rm_oa << *m_RM;
                    rm_bytes = rm_oss.str().size();
                }
                fprintf(stderr,
                        "[OP-PROF] op=%d memory=%zu kb_state=%zu scanned=%zu diag=%zu safety=%zu "
                        "events=%zu maneuver=%zu hfe=%zu rm=%zu\n",
                        type_of_operator, blob_bytes(memory), kb_oss.str().size(),
                        blob_bytes(scanned_indicators), blob_bytes(diagnosis_matrix),
                        blob_bytes(safety_parameters), blob_bytes(event_actions),
                        blob_bytes(maneuver_action), blob_bytes(hfe_bbn), rm_bytes);
            }
        }
        // Serialize m_RM as an isolated binary buffer
        {
            bool has_rm = (m_RM != nullptr);
            ar & has_rm;
            if (has_rm) {
                std::string rm_data;
                if constexpr (Archive::is_saving::value) {
                    std::ostringstream rm_oss(std::ios::binary);
                    boost::archive::binary_oarchive rm_oa(rm_oss);
                    rm_oa << *m_RM;
                    rm_data = rm_oss.str();
                }
                ar & rm_data;
                if constexpr (Archive::is_loading::value) {
                    m_RM = std::make_unique<ReasonMachine>();
                    std::istringstream rm_iss(rm_data, std::ios::binary);
                    boost::archive::binary_iarchive rm_ia(rm_iss);
                    rm_ia >> *m_RM;
                }
            } else if constexpr (Archive::is_loading::value) {
                m_RM.reset();
            }
        }
    }
 private:
  int type_of_operator;//sim::Operator::OAT; sim::Operator::ODM, and sim::Operator::OAT
  int mental_procedure_priority_threshold;
  int scan_queue_limit;
  bool pause_activity;
  bool pause_mental_procedure;
  bool skip_procedure_step;
  bool skip_instinctive_response_step;
  bool abnormal_signal_perceived;
  bool block_troubleshooting;
  bool block_procedure_use;
  bool new_branch_generated;
  double abnormal_signal_threshold;
  double threshold_value_for_HWKB_confidence; //(0.0 <= x <= 100)
  double action_time_multiplier;
  double skip_action_threshold, skip_non_response_threshold;
  double troubleshooting_probability;
  double procedure_use_probability;
  double nominal_communication_time;
  bool info_gather_mode_branch_generated;
  double use_of_old_info_probability;
};
 
BOOST_CLASS_EXPORT_KEY(Operator)