KBHardWiredUnit.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <typeinfo>
// KBHardWiredUnit.h: interface for the KBHardWiredUnit class.
//
 
#include "KBElement.h"
#include "KBExpectedAlarmStateUnit.h"
#include "KBExpectedComponentStateUnit.h"
#include "KBExpectedParameterValueUnit.h"
#include "KBExpectedParameterTrendUnit.h"
#include "HardWiredControlActivity.h"
#include "HardWiredMentalBelief.h"
#include "HardWiredProcedureActivity.h"
#include "../ControlPanel/StateOfActivation.h"
#include "../Procedure/ProcedureStepInfo.h"
#include "../CalculationAid/Timer.h"
#include "../CalculationAid/Probability.h"
#include <boost/serialization/export.hpp>
 
// Include Boost Serialization headers
#include <boost/serialization/vector.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/assume_abstract.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <fstream>
#include <memory>
#include <vector>
#include <boost/serialization/unique_ptr.hpp>
 
namespace boost { namespace archive {
class binary_oarchive;
class binary_iarchive;
} }
 
class KBHardWiredUnit : public KBElement, public StateOfActivation, public ProcedureStepInfo {
public:
    // State hooks: activation, confidence, fulfilled counters, and the
    // expectation elements' state. Definitions are re-seeded from the operator's
    // KB master. serialize() carries every member (rinfo text paths, defensive uses).
    void state_save(boost::archive::binary_oarchive& ar) const;
    void state_load(boost::archive::binary_iarchive& ar);
 
    KBHardWiredUnit();
    virtual ~KBHardWiredUnit();
    void readInfoFromFile(std::ifstream &);
    void recalculateConfidenceLevel();
    double calculateConfidenceLevel();
    double getConfidenceLevel();
    void calculateTotalNumberOfExpectation();
    void checkForAlarmState(std::string, int);
    void checkForComponentState(std::string, int);
    void checkForSupportSystemState(std::string, int);
    void checkForParameterValue(std::string, double, int);
    void checkForParameterTrend(std::string, int);
    void checkForControl(std::string, double);
    void checkForMentalBelief(std::string, int);
    void checkForProcedureActivity(std::string, int);
    void copyKBHardWiredUnit(KBHardWiredUnit &);
    void setTotalNumberOfExpectation(int);
    void setNumberOfFulfilledAlarmState(int);
    void setNumberOfFulfilledComponentState(int);
    void setNumberOfFulfilledSupportSystemState(int);
    void setNumberOfFulfilledParameterValue(int);
    void setNumberOfFulfilledParameterTrend(int);
    void setNumberOfFulfilledControl(int);
    void setNumberOfFulfilledProcedureActivity(int);
    void setNumberOfFulfilledMentalBelief(int);
    void setMentalProcedurePriority(int);
    int getNumberOfFulfilledControl();
    int getNumberOfFulfilledMentalBelief();
    int getTotalNumberOfExpectation();
    int getNumberOfFulfilledAlarmState();
    int getNumberOfFulfilledComponentState();
    int getNumberOfFulfilledSupportSystemState();
    int getNumberOfFulfilledParameterValue();
    int getNumberOfFulfilledParameterTrend();
    int getNumberOfFulfilledProcedureActivity();
    int getMentalProcedurePriority();
    void saveKBHardWiredUnitToFile(std::ofstream &);
    void retrieveKBHardWiredUnitFromFile(std::ifstream &);
    std::vector<std::unique_ptr<KBExpectedAlarmStateUnit>> expected_alarm_state;
    std::vector<std::unique_ptr<KBExpectedComponentStateUnit>> expected_component_state;
    std::vector<std::unique_ptr<KBExpectedSupportSystemStateUnit>> expected_support_system_state;
    std::vector<std::unique_ptr<KBExpectedParameterValueUnit>> expected_parameter_value;
    std::vector<std::unique_ptr<KBExpectedParameterTrendUnit>> expected_parameter_trend;
    std::vector<std::unique_ptr<HardWiredControlActivity>> expected_control;
    std::vector<std::unique_ptr<HardWiredMentalBelief>> expected_mental_belief;
    std::vector<std::unique_ptr<HardWiredProcedureActivity>> expected_procedure_activity;
    Timer activation_delay, dormancy_time;
    Probability branch_probability, activation_probability;
 
private:
    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 & boost::serialization::base_object<KBElement>(*this);
        ar & boost::serialization::base_object<StateOfActivation>(*this);
        ar & boost::serialization::base_object<ProcedureStepInfo>(*this);
        // Serialize all members
        ar & confidence_level;
        ar & total_number_of_expectation;
        ar & number_of_fulfilled_alarm_state;
        ar & number_of_fulfilled_component_state;
        ar & number_of_fulfilled_support_system_state;
        ar & number_of_fulfilled_parameter_value;
        ar & number_of_fulfilled_parameter_trend;
        ar & number_of_fulfilled_control;
        ar & number_of_fulfilled_mental_belief;
        ar & number_of_fulfilled_procedure_activity;
        ar & mental_procedure_priority;
        // Serialize vectors of pointers requires special handling
        // This is a simplified approach and might need adjustment based on actual object serialization needs
        ar & expected_alarm_state;
        ar & expected_component_state;
        ar & expected_support_system_state;
        ar & expected_parameter_value;
        ar & expected_parameter_trend;
        ar & expected_control;
        ar & expected_mental_belief;
        ar & expected_procedure_activity;
        ar & activation_delay;
        ar & dormancy_time;
        ar & branch_probability;
        ar & activation_probability;
    }
 
    double confidence_level;
    int total_number_of_expectation;
    int number_of_fulfilled_alarm_state, number_of_fulfilled_component_state, number_of_fulfilled_support_system_state,
            number_of_fulfilled_parameter_value,
            number_of_fulfilled_parameter_trend;
    int number_of_fulfilled_control, number_of_fulfilled_mental_belief;
    int number_of_fulfilled_procedure_activity;
    int mental_procedure_priority;
};
 
 
BOOST_CLASS_EXPORT_KEY(KBHardWiredUnit)