KeyParameterHistoryUnit.cpp

Go to the documentation of this file.

// KeyParameterHistoryUnit.cpp: implementation of the KeyParameterHistoryUnit class.
//
 
#include "KeyParameterHistoryUnit.h"
#include "../ControlPanel/ControlPanelAlarm.h"
#include "../ControlPanel/ControlPanelDisplay.h"
#include "../ControlPanel/ControlPanelControl.h"
#include "../Crew/KBHardWiredUnit.h"
#include "../Crew/KB.h"
#include "fmodule.h"
#include "../Crew/OperatorDM.h"
#include "../Crew/OperatorAT.h"
#include "../ControlPanel/ControlPanel.h"
#include "../Crew/SymptomUnit.h"
#include "../Crew/DiagnosisEventUnit.h"
#include "../Crew/EventSymptomMatrix.h"
#include "../Crew/SPDS.h"
#include "../Crew/SPDSUnit.h"
#include "../Crew/TimeConstrainedUnit.h"
#include "../Crew/TimeConstrainedModule.h"
#include <boost/serialization/export.hpp>
#include "SimulationContext.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(KeyParameterHistoryUnit)
using namespace std;
 
 
// Construction/Destruction
 
KeyParameterHistoryUnit::KeyParameterHistoryUnit()
{
 
}
 
KeyParameterHistoryUnit::~KeyParameterHistoryUnit()
{
 
}
void KeyParameterHistoryUnit::setCurrentTime(double x){current_time = x;}
double KeyParameterHistoryUnit::getCurrentTime(){return current_time;}
void KeyParameterHistoryUnit::addDataSet(){
    vector<unique_ptr<DisplayParameterValue>>::iterator dpv_itr;
    vector<unique_ptr<DisplayParameterValueRate>>::iterator dpvr_itr;
    vector<unique_ptr<DisplayHeatStructure>>::iterator hs_itr;
    vector<unique_ptr<DisplayComponentState>>::iterator dcs_itr;
    vector<unique_ptr<DisplaySupportSystemState>>::iterator dsss_itr;
    vector<unique_ptr<AlarmParameter>>::iterator ap_itr;
    vector<unique_ptr<AlarmComponent>>::iterator ac_itr;
    vector<unique_ptr<AlarmTwoParameterDifference>>::iterator atpd_itr;
    vector<unique_ptr<ControlState>>::iterator cs_itr;
    vector<unique_ptr<ControlValue>>::iterator cv_itr;
    decltype(g_sim.Decision_Maker.knowledge_base.hard_wired_diagnosis)::iterator hwd_itr;
    decltype(g_sim.Decision_Maker.diagnosis_matrix.symptoms)::iterator symptoms_itr;
    decltype(g_sim.Decision_Maker.diagnosis_matrix.events)::iterator events_itr;
    decltype(g_sim.Decision_Maker.safety_parameters.spds_input_array)::iterator spds_input_array_itr;
    decltype(g_sim.Decision_Maker.time_constrained_load.Time_Constrained_Parameter_Array)::iterator time_constrained_data_itr;
 
    //
    current_time = r5pars_.timesno; 
    //Display
    for(dpv_itr = g_sim.Indicator.indicators.parameter_value_array.begin(); dpv_itr != g_sim.Indicator.indicators.parameter_value_array.end(); dpv_itr++){
        this->parameter_value_array.push_back((*dpv_itr)->getDisplayedParameterValue());
    }
    for(dpvr_itr = g_sim.Indicator.indicators.parameter_trend_array.begin(); dpvr_itr != g_sim.Indicator.indicators.parameter_trend_array.end(); dpvr_itr++){
        this->parameter_trend_array.push_back((*dpvr_itr)->getRateOfChange());
    }
    for(hs_itr = g_sim.Indicator.indicators.heat_structure_array.begin(); hs_itr != g_sim.Indicator.indicators.heat_structure_array.end(); hs_itr++){
        this->mesh_point_value_array.push_back((*hs_itr)->getDisplayedParameterValue()); 
    }
    for(dcs_itr = g_sim.Indicator.indicators.component_state_array.begin(); dcs_itr != g_sim.Indicator.indicators.component_state_array.end(); dcs_itr++){
        this->component_state_array.push_back((*dcs_itr)->getDisplayedComponentOperationalState());
    }
    for(dsss_itr = g_sim.Indicator.indicators.support_systems_state_array.begin(); dsss_itr != g_sim.Indicator.indicators.support_systems_state_array.end(); dsss_itr++){
        this->component_state_array.push_back((*dsss_itr)->getDisplayedSupportSystemOperationalState());
    }
    //alarms
    for(ap_itr = g_sim.Indicator.alarms.alarm_parameter_value_array.begin(); ap_itr != g_sim.Indicator.alarms.alarm_parameter_value_array.end(); ap_itr++){
        this->alarm_parameter_value_array.push_back((*ap_itr)->getDisplayedAlarmState());
    }
    for(ac_itr = g_sim.Indicator.alarms.alarm_component_state_array.begin(); ac_itr != g_sim.Indicator.alarms.alarm_component_state_array.end(); ac_itr++){
        this->alarm_component_state_array.push_back((*ac_itr)->getDisplayedAlarmState());
    }
    for(atpd_itr = g_sim.Indicator.alarms.alarm_value_difference_array.begin(); atpd_itr != g_sim.Indicator.alarms.alarm_value_difference_array.end(); atpd_itr++){
        this->alarm_value_difference_array.push_back((*atpd_itr)->getDisplayedAlarmState());
    }
    //controls
    for(cs_itr = g_sim.Indicator.controls.control_state_array.begin(); cs_itr != g_sim.Indicator.controls.control_state_array.end(); cs_itr++){
    //  this->control_state_array.push_back((*cs_itr)->getDisplayedControlValue());
        // modified by kac 1/15/07 to display actual control value for manual actions
        this->control_state_array.push_back((*cs_itr)->getControlValue());
    }
    for(cv_itr = g_sim.Indicator.controls.control_value_array.begin(); cv_itr != g_sim.Indicator.controls.control_value_array.end(); cv_itr++){
    //  this->control_value_array.push_back((*cv_itr)->getDisplayedControlValue());
        // modified by kac 1/15/07 to display actual control value for manual actions
        this->control_value_array.push_back((*cv_itr)->getControlValue());
    }
    for(hwd_itr = g_sim.Decision_Maker.knowledge_base.hard_wired_diagnosis.begin(); hwd_itr != g_sim.Decision_Maker.knowledge_base.hard_wired_diagnosis.end(); hwd_itr++){
        this->ODM_hardwiredKB_confidence.push_back((*hwd_itr)->getConfidenceLevel());
    }
    for(hwd_itr = g_sim.Action_Taker.knowledge_base.hard_wired_diagnosis.begin(); hwd_itr != g_sim.Action_Taker.knowledge_base.hard_wired_diagnosis.end(); hwd_itr++){
        this->OAT_hardwiredKB_confidence.push_back((*hwd_itr)->getConfidenceLevel());
    }
    //
    for(symptoms_itr = g_sim.Decision_Maker.diagnosis_matrix.symptoms.begin(); 
        symptoms_itr != g_sim.Decision_Maker.diagnosis_matrix.symptoms.end(); symptoms_itr++){
        this->ODM_symptom_confidence.push_back((*symptoms_itr)->getConfidence());
    }
    for(events_itr = g_sim.Decision_Maker.diagnosis_matrix.events.begin(); 
        events_itr != g_sim.Decision_Maker.diagnosis_matrix.events.end(); events_itr++){
        this->ODM_event_confidence.push_back((*events_itr)->getConfidence());
        this->ODM_event_lower_bound.push_back((*events_itr)->getLowerBound());
        this->ODM_event_upper_bound.push_back((*events_itr)->getUpperBound());
    }
    for(symptoms_itr = g_sim.Action_Taker.diagnosis_matrix.symptoms.begin(); 
        symptoms_itr != g_sim.Action_Taker.diagnosis_matrix.symptoms.end(); symptoms_itr++){
        this->OAT_symptom_confidence.push_back((*symptoms_itr)->getConfidence());
    }
    for(events_itr = g_sim.Action_Taker.diagnosis_matrix.events.begin(); 
        events_itr != g_sim.Action_Taker.diagnosis_matrix.events.end(); events_itr++){
        this->OAT_event_confidence.push_back((*events_itr)->getConfidence());
        this->OAT_event_lower_bound.push_back((*events_itr)->getLowerBound());
        this->OAT_event_upper_bound.push_back((*events_itr)->getUpperBound());
    }
//  add SPDS data
/*  this->spds_array.push_back(g_sim.Indicator.safety_par_display_system.getSPDSValue());
    this->spds_array.push_back(g_sim.Indicator.safety_par_display_system.getSPDSRate());
    for(spds_input_array_itr = g_sim.Indicator.safety_par_display_system.spds_input_array.begin(); 
    spds_input_array_itr != g_sim.Indicator.safety_par_display_system.spds_input_array.end(); spds_input_array_itr++)
    {
        this->spds_array.push_back((*spds_input_array_itr)->getSPDSUnitValue());
    }
*/
    this->ODM_safety_parameters.push_back(g_sim.Decision_Maker.safety_parameters.getSPDSValue());
    this->ODM_safety_parameters.push_back(g_sim.Decision_Maker.safety_parameters.getSPDSRate());
    for(spds_input_array_itr = g_sim.Decision_Maker.safety_parameters.spds_input_array.begin(); spds_input_array_itr != g_sim.Decision_Maker.safety_parameters.spds_input_array.end(); spds_input_array_itr++)
    {
        this->ODM_safety_parameters.push_back((*spds_input_array_itr)->getSPDSUnitValue());
    }
    this->OAT_safety_parameters.push_back(g_sim.Action_Taker.safety_parameters.getSPDSValue());
    this->OAT_safety_parameters.push_back(g_sim.Action_Taker.safety_parameters.getSPDSRate());
    for(spds_input_array_itr = g_sim.Action_Taker.safety_parameters.spds_input_array.begin(); spds_input_array_itr != g_sim.Action_Taker.safety_parameters.spds_input_array.end(); spds_input_array_itr++)
    {
        this->OAT_safety_parameters.push_back((*spds_input_array_itr)->getSPDSUnitValue());
    }
//  add operator specific time constrained data for Decision Maker
 
 
    //
    this->ODM_time_constrained_load.push_back(g_sim.Decision_Maker.time_constrained_load.getTimeConstrainedPIFValue());
    for(time_constrained_data_itr  = g_sim.Decision_Maker.time_constrained_load.Time_Constrained_Parameter_Array.begin();
        time_constrained_data_itr != g_sim.Decision_Maker.time_constrained_load.Time_Constrained_Parameter_Array.end();
        time_constrained_data_itr++) 
        {
            this->ODM_time_constrained_load.push_back((*time_constrained_data_itr)->getParameterValue());
            this->ODM_time_constrained_load.push_back((*time_constrained_data_itr)->getParameterRate());
            this->ODM_time_constrained_load.push_back((*time_constrained_data_itr)->getTimeToNormalThreshold());
            this->ODM_time_constrained_load.push_back((*time_constrained_data_itr)->getTimeToAccidentThreshold());
        }
//
//  add information load data for Decision Maker
    this->ODM_information_load.push_back(g_sim.Decision_Maker.information_load.getInfoLoadPIFValue());
//
//  add operator specific time constrained data for Action Taker
 
 
    this->OAT_time_constrained_load.push_back(g_sim.Action_Taker.time_constrained_load.getTimeConstrainedPIFValue());
    for(time_constrained_data_itr  = g_sim.Action_Taker.time_constrained_load.Time_Constrained_Parameter_Array.begin();
        time_constrained_data_itr != g_sim.Action_Taker.time_constrained_load.Time_Constrained_Parameter_Array.end();
        time_constrained_data_itr++)
        {
            this->OAT_time_constrained_load.push_back((*time_constrained_data_itr)->getParameterValue());
            this->OAT_time_constrained_load.push_back((*time_constrained_data_itr)->getParameterRate());
            this->OAT_time_constrained_load.push_back((*time_constrained_data_itr)->getTimeToNormalThreshold());
            this->OAT_time_constrained_load.push_back((*time_constrained_data_itr)->getTimeToAccidentThreshold());
        }
//
//  add information load data for Action Taker
    this->OAT_information_load.push_back(g_sim.Action_Taker.information_load.getInfoLoadPIFValue());
//
}
 
void KeyParameterHistoryUnit::outputAllDataToFile(ofstream &fout){
    int i;
    fout << current_time;
    for(i = 0; i < parameter_value_array.size(); i++){
        fout << '\t' << parameter_value_array.at(i);
    }
    for(i = 0; i < parameter_trend_array.size(); i++){
        fout << '\t' << parameter_trend_array.at(i);
    }
    for(i = 0; i < mesh_point_value_array.size(); i++){
        fout << '\t' << mesh_point_value_array.at(i);
    } 
    for(i = 0; i < component_state_array.size(); i++){
        fout << '\t' <<  component_state_array.at(i);
    }
    for(i = 0; i < alarm_parameter_value_array.size(); i++){
        fout << '\t' << alarm_parameter_value_array.at(i);
    }
    for(i = 0; i < alarm_component_state_array.size(); i++){
        fout << '\t' << alarm_component_state_array.at(i);
    }
    for(i = 0; i < alarm_value_difference_array.size(); i++){
        fout << '\t' << alarm_value_difference_array.at(i);
    }
    for(i = 0; i < control_state_array.size(); i++){
        fout << '\t' << control_state_array.at(i);
    }
    for(i = 0; i < control_value_array.size(); i++){
        fout << '\t' << control_value_array.at(i);
    }
    for(i = 0; i < ODM_hardwiredKB_confidence.size(); i++){
        fout << '\t' << ODM_hardwiredKB_confidence.at(i);
    }
    for(i = 0; i < OAT_hardwiredKB_confidence.size(); i++){
        fout << '\t' << OAT_hardwiredKB_confidence.at(i);
    }
    fout << '\n';
}
void KeyParameterHistoryUnit::outputAllDiagnosisDataToFile(ofstream &fout){
    int i;
    fout << current_time;
    for(i = 0; i < ODM_symptom_confidence.size(); i++){
        fout << '\t' << ODM_symptom_confidence.at(i);
    }
    for(i = 0; i < ODM_event_confidence.size(); i++){
        fout << '\t' << ODM_event_confidence.at(i);
//          << '\t' << ODM_event_lower_bound.at(i)
//          << '\t' << ODM_event_upper_bound.at(i);
    }
    for(i = 0; i < OAT_symptom_confidence.size(); i++){
        fout << '\t' << OAT_symptom_confidence.at(i);
    }
    for(i = 0; i < OAT_event_confidence.size(); i++){
        fout << '\t' << OAT_event_confidence.at(i);
//          << '\t' << OAT_event_lower_bound.at(i)
//          << '\t' << OAT_event_upper_bound.at(i);
    }
    fout << '\n';
}
 
void KeyParameterHistoryUnit::outputAllPIFDataToFile(ofstream &fout){
    int i;
    fout << current_time;
    //
    for(i = 0; i < ODM_safety_parameters.size(); i++){
        fout << '\t' << ODM_safety_parameters.at(i);
    }
    //
    for(i = 0; i < OAT_safety_parameters.size(); i++){
        fout << '\t' << OAT_safety_parameters.at(i);
    }
 
    
 
 
    for(i = 0; i < ODM_time_constrained_load.size() ; i++){
        fout << '\t' << ODM_time_constrained_load.at(i);
    }
    for(i = 0; i < OAT_time_constrained_load.size(); i++){
        fout << '\t' << OAT_time_constrained_load.at(i);
    }
 
    for(i = 0; i < ODM_information_load.size() ; i++){
        fout << '\t' << ODM_information_load.at(i);
    }
    for(i = 0; i < OAT_information_load.size(); i++){
        fout << '\t' << OAT_information_load.at(i);
    }
 
    fout << '\n';
 
}
 
void KeyParameterHistoryUnit::outputLabelToFile(ofstream &fout){
    fout << "Time";
    g_sim.Indicator.indicators.outputParametersLabelsToFile(fout);
    g_sim.Indicator.alarms.outputParametersLabelsToFile(fout);
    g_sim.Indicator.controls.outputParametersLabelsToFile(fout);
    g_sim.Decision_Maker.knowledge_base.outputHardWiredDiagnosisLabelToFile("ODM_", fout);
    g_sim.Action_Taker.knowledge_base.outputHardWiredDiagnosisLabelToFile("OAT_", fout);
    fout << '\n';
}
void KeyParameterHistoryUnit::outputDiagnosisLabelToFile(ofstream &fout){
    fout << "Time";
    g_sim.Decision_Maker.diagnosis_matrix.outputEventSymptomMatrixLabelToFile("ODMDIA_",fout);
    g_sim.Action_Taker.diagnosis_matrix.outputEventSymptomMatrixLabelToFile("OATDIA_",fout);
    fout << '\n';
}
 
void KeyParameterHistoryUnit::outputPIFLabelToFile(ofstream &fout){
    fout << "Time";
    //Indicator.safety_par_display_system.outputSPDSLabelToFile(fout);
    //
    g_sim.Decision_Maker.safety_parameters.outputSPDSLabelToFile("ODM_",fout);
    g_sim.Action_Taker.safety_parameters.outputSPDSLabelToFile("OAT_",fout);
    //
 
 
    g_sim.Decision_Maker.time_constrained_load.outputTimeConstrainedLabelToFile("ODM_",fout);
    g_sim.Action_Taker.time_constrained_load.outputTimeConstrainedLabelToFile("OAT_", fout);
    //
    g_sim.Decision_Maker.information_load.outputInformationLoadModuleLabelToFile("ODM_", fout);
    g_sim.Action_Taker.information_load.outputInformationLoadModuleLabelToFile("OAT_", fout);
    //
    fout << '\n';
}
 
void KeyParameterHistoryUnit::outputUnitToFile(ofstream &fout){
    fout << "(sec)";
    g_sim.Indicator.indicators.outputParametersUnitsToFile(fout);
    g_sim.Indicator.alarms.outputParametersUnitsToFile(fout);
    g_sim.Indicator.controls.outputParametersUnitsToFile(fout);
    g_sim.Decision_Maker.knowledge_base.outputHardWiredDiagnosisUnitToFile(fout);
    g_sim.Action_Taker.knowledge_base.outputHardWiredDiagnosisUnitToFile(fout);
    fout << '\n';
}
void KeyParameterHistoryUnit::outputDiagnosisUnitToFile(ofstream &fout){
    fout << "(sec)";
    g_sim.Decision_Maker.diagnosis_matrix.outputEventSymptomMatrixUnitToFile(fout);
    g_sim.Action_Taker.diagnosis_matrix.outputEventSymptomMatrixUnitToFile(fout);
    fout << '\n';
}
void KeyParameterHistoryUnit::outputPIFUnitToFile(ofstream &fout){
    fout << "(sec)";
    //Indicator.safety_par_display_system.outputSPDSUnitToFile(fout);
    //
    g_sim.Decision_Maker.safety_parameters.outputSPDSUnitToFile(fout);
    g_sim.Action_Taker.safety_parameters.outputSPDSUnitToFile(fout);
    //
//  Decision_Maker.Relap_PIFs.Time_Constrained_Data.outputTimeConstrainedUnitsToFile(fout);
//  Action_Taker.Relap_PIFs.Time_Constrained_Data.outputTimeConstrainedUnitsToFile(fout);
    //
    g_sim.Decision_Maker.time_constrained_load.outputTimeConstrainedUnitsToFile(fout);
    g_sim.Action_Taker.time_constrained_load.outputTimeConstrainedUnitsToFile(fout);
    //
    g_sim.Decision_Maker.information_load.outputInformationLoadModuleUnitsToFile(fout);
    g_sim.Action_Taker.information_load.outputInformationLoadModuleUnitsToFile(fout);
    //  
    fout << '\n';
}
int KeyParameterHistoryUnit::getNumOfData(){    
    int num;
    num = parameter_value_array.size() + component_state_array.size() +     mesh_point_value_array.size() +  parameter_trend_array.size() +
    alarm_parameter_value_array.size() + alarm_component_state_array.size() + alarm_value_difference_array.size() + 
    control_state_array.size() + control_value_array.size() + ODM_hardwiredKB_confidence.size() + OAT_hardwiredKB_confidence.size()
    + 1;
    return num;
}
int KeyParameterHistoryUnit::getDiagnosisNumOfData(){
    int num;
    num = ODM_symptom_confidence.size()
    + OAT_symptom_confidence.size()
    + ODM_event_confidence.size()
    + OAT_event_confidence.size()
//  + ODM_event_lower_bound.size()
//  + OAT_event_lower_bound.size()
//  + ODM_event_upper_bound.size()
//  + OAT_event_upper_bound.size()
    + 1;
    return num;
}
 
int KeyParameterHistoryUnit::getPIFNumOfData(){
    int num;
    num = ODM_safety_parameters.size()
        + OAT_safety_parameters.size()
//      + ODM_RelapPIFs.size()
//      + OAT_RelapPIFs.size()
        + ODM_time_constrained_load.size()
        + OAT_time_constrained_load.size()
        + ODM_information_load.size()
        + OAT_information_load.size()
        + 1;
    return num;
}
 
void KeyParameterHistoryUnit::clearKeyParameterHistoryUnit(){
    parameter_value_array.clear();
    mesh_point_value_array.clear(); 
    component_state_array.clear();
    parameter_trend_array.clear();
    alarm_parameter_value_array.clear();
    alarm_component_state_array.clear();
    alarm_value_difference_array.clear();
    control_state_array.clear();
    control_value_array.clear();
    ODM_hardwiredKB_confidence.clear();
    OAT_hardwiredKB_confidence.clear();
    ODM_symptom_confidence.clear();
    OAT_symptom_confidence.clear();
    ODM_event_confidence.clear();
    OAT_event_confidence.clear();
    ODM_event_lower_bound.clear();
    OAT_event_lower_bound.clear();
    ODM_event_upper_bound.clear();
    OAT_event_upper_bound.clear();
    ODM_safety_parameters.clear();
    OAT_safety_parameters.clear();
    //spds_array.clear();
    ODM_RelapPIFs.clear();
    OAT_RelapPIFs.clear();
    ODM_time_constrained_load.clear();
    OAT_time_constrained_load.clear();
    ODM_information_load.clear();
    OAT_information_load.clear();
}
void KeyParameterHistoryUnit::copyKeyParameterHistoryUnit(KeyParameterHistoryUnit &kph){
    current_time = kph.getCurrentTime();
    // Vector copy-assignment: one exact-size allocation + memcpy per vector
    // instead of element-wise push_back growth. Assignment replaces the
    // target's contents; callers pass freshly constructed (empty) units.
    parameter_value_array = kph.parameter_value_array;
    parameter_trend_array = kph.parameter_trend_array;
    mesh_point_value_array = kph.mesh_point_value_array;
    component_state_array = kph.component_state_array;
    alarm_parameter_value_array = kph.alarm_parameter_value_array;
    alarm_component_state_array = kph.alarm_component_state_array;
    alarm_value_difference_array = kph.alarm_value_difference_array;
    control_state_array = kph.control_state_array;
    control_value_array = kph.control_value_array;
    ODM_hardwiredKB_confidence = kph.ODM_hardwiredKB_confidence;
    OAT_hardwiredKB_confidence = kph.OAT_hardwiredKB_confidence;
    ODM_symptom_confidence = kph.ODM_symptom_confidence;
    OAT_symptom_confidence = kph.OAT_symptom_confidence;
    ODM_event_confidence = kph.ODM_event_confidence;
    OAT_event_confidence = kph.OAT_event_confidence;
    ODM_event_lower_bound = kph.ODM_event_lower_bound;
    OAT_event_lower_bound = kph.OAT_event_lower_bound;
    ODM_event_upper_bound = kph.ODM_event_upper_bound;
    OAT_event_upper_bound = kph.OAT_event_upper_bound;
    ODM_safety_parameters = kph.ODM_safety_parameters;
    OAT_safety_parameters = kph.OAT_safety_parameters;
    // ODM_RelapPIFs / OAT_RelapPIFs are intentionally not copied.
    ODM_time_constrained_load = kph.ODM_time_constrained_load;
    OAT_time_constrained_load = kph.OAT_time_constrained_load;
    ODM_information_load = kph.ODM_information_load;
    OAT_information_load = kph.OAT_information_load;
}
 
void KeyParameterHistoryUnit::saveKeyParameterHistoryUnitToFile(ofstream &fout){
    int i, modi;
    double xtemp;
    fout << current_time << '\n';
    fout << parameter_value_array.size() << '\n';
    for(i = 0; i < parameter_value_array.size(); i++){
        //kac added to avoid numerical issues in output file - 9/12/10
        xtemp = parameter_value_array.at(i);
        if (xtemp > -1e-30 && xtemp < 1e-30) {
            xtemp = 0.0;
        }
        //kac
        fout << xtemp;
        //
        // add carriage return to avoid long file line lengths
        modi = (i + 1) % 50;
        if ( modi == 0) {
            fout << '\n';
        }
        else
        {
            fout << ' ';
        }
        //
        //fout << ' ' << parameter_value_array.at(i);
    }
    fout << '\n';
    //
    fout << parameter_trend_array.size() << ' ';
    for(i = 0; i < parameter_trend_array.size(); i++){
        //
        xtemp = parameter_trend_array.at(i);
        if (xtemp > -1e-30 && xtemp < 1e-30) {
            xtemp = 0.0;
        }
        //kac
        fout << xtemp;
        //
        // add carriage return to avoid long file line lengths
        modi = (i + 1) % 50;
        if ( modi == 0) {
            fout << '\n';
        }
        else
        {
            fout << ' ';
        }
        //
        //fout << ' ' << parameter_trend_array.at(i);
    }
    fout << '\n';
    fout << component_state_array.size() ;
    for(i = 0; i < component_state_array.size(); i++){
        fout << ' ' << component_state_array.at(i);
    }
    fout << '\n';
    fout << mesh_point_value_array.size();
    for(i = 0; i < mesh_point_value_array.size(); i++){
        fout << ' ' << mesh_point_value_array.at(i);
    }
    fout << '\n';
    fout << alarm_parameter_value_array.size();
    for(i = 0; i < alarm_parameter_value_array.size(); i++){
        fout << ' ' << alarm_parameter_value_array.at(i);
    }
    fout << '\n';
    fout << alarm_component_state_array.size();
    for(i = 0; i < alarm_component_state_array.size(); i++){
        fout << ' ' << alarm_component_state_array.at(i);
    }
    fout << '\n';
    fout << alarm_value_difference_array.size();
    for(i = 0; i < alarm_value_difference_array.size(); i++){
        fout << ' ' << alarm_value_difference_array.at(i);
    }
    fout << '\n';
    fout << control_state_array.size();
    for(i = 0; i < control_state_array.size(); i++){
        fout << ' ' << control_state_array.at(i);
    }
    fout << '\n';
    fout << control_value_array.size();
    for(i = 0; i < control_value_array.size(); i++){
        fout << ' ' << control_value_array.at(i);
    }
    fout << '\n';
    fout << ODM_hardwiredKB_confidence.size();
    for(i = 0; i < ODM_hardwiredKB_confidence.size(); i++){
        fout << ' ' << ODM_hardwiredKB_confidence.at(i);
    }
    fout << '\n';
    fout << OAT_hardwiredKB_confidence.size();
    for(i = 0; i < OAT_hardwiredKB_confidence.size(); i++){
        fout << ' ' << OAT_hardwiredKB_confidence.at(i);
    }
    fout << '\n';
    fout << ODM_symptom_confidence.size();
    for(i = 0; i < ODM_symptom_confidence.size(); i++){
        fout << ' ' << ODM_symptom_confidence.at(i);
    }
    fout << '\n';
    fout << OAT_symptom_confidence.size();
    for(i = 0; i < OAT_symptom_confidence.size(); i++){
        fout << ' ' << OAT_symptom_confidence.at(i);
    }
    fout << '\n';
    fout << ODM_event_confidence.size();
    for(i = 0; i < ODM_event_confidence.size(); i++){
        fout << ' ' << ODM_event_confidence.at(i);
    }
    fout << '\n';
    fout << OAT_event_confidence.size();
    for(i = 0; i < OAT_event_confidence.size(); i++){
        fout << ' ' << OAT_event_confidence.at(i);
    }
    fout << '\n';
    fout << ODM_event_lower_bound.size();
    for(i = 0; i < ODM_event_lower_bound.size(); i++){
        fout << ' ' << ODM_event_lower_bound.at(i);
    }
    fout << '\n';
    fout << OAT_event_lower_bound.size();
    for(i = 0; i < OAT_event_lower_bound.size(); i++){
        fout << ' ' << OAT_event_lower_bound.at(i);
    }
    fout << '\n';
    fout << ODM_event_upper_bound.size();
    for(i = 0; i < ODM_event_upper_bound.size(); i++){
        fout << ' ' << ODM_event_upper_bound.at(i);
    }
    fout << '\n';
    fout << OAT_event_upper_bound.size();
    for(i = 0; i < OAT_event_upper_bound.size(); i++){
        fout << ' ' << OAT_event_upper_bound.at(i);
    }
    //
    fout << '\n';
    fout << ODM_safety_parameters.size() << ' ';
    for(i = 0; i < ODM_safety_parameters.size(); i++){
        //
        xtemp = ODM_safety_parameters.at(i);
        if (xtemp > -1e-30 && xtemp < 1e-30) {
            xtemp = 0.0;
        }
        //
        fout << xtemp;
        //
        // add carriage return to avoid long file line lengths
        modi = (i + 1) % 50;
        if ( modi == 0) {
            fout << '\n';
        }
        else
        {
            fout << ' ';
        }
        //
        
        //fout << ' ' << ODM_safety_parameters.at(i);
    }
    fout << '\n';
    fout << OAT_safety_parameters.size() << ' ';
    for(i = 0; i < OAT_safety_parameters.size(); i++){
        //
        xtemp = OAT_safety_parameters.at(i);
        if (xtemp > -1e-30 && xtemp < 1e-30) {
            xtemp = 0.0;
        }
        //
        fout << xtemp;
        //
        // add carriage return to avoid long file line lengths
        modi = (i + 1) % 50;
        if ( modi == 0) {
            fout << '\n';
        }
        else
        {
            fout << ' ';
        }
        //
        
        //fout << ' ' << OAT_safety_parameters.at(i);
    }
    fout << '\n';
    //
    //
    fout << ODM_time_constrained_load.size() << ' ';
    for(i = 0; i < ODM_time_constrained_load.size(); i++){
        //
        xtemp = ODM_time_constrained_load.at(i);
        if (xtemp > -1e-30 && xtemp < 1e-30) {
            xtemp = 0.0;
        }
        //
        fout << xtemp;
        //
        // add carriage return to avoid long file line lengths
        modi = (i + 1) % 50;
        if ( modi == 0) {
            fout << '\n';
        }
        else
        {
            fout << ' ';
        }
        //
        
        //fout << ' ' << ODM_time_constrained_load.at(i);
    }
    fout << '\n';
    //
    fout << OAT_time_constrained_load.size() << ' ';
    for(i = 0; i < OAT_time_constrained_load.size(); i++){
        //
        xtemp = OAT_time_constrained_load.at(i);
        if (xtemp > -1e-30 && xtemp < 1e-30) {
            xtemp = 0.0;
        }
        //
        fout << xtemp;
        //
        // add carriage return to avoid long file line lengths
        modi = (i + 1) % 50;
        if ( modi == 0) {
            fout << '\n';
        }
        else
        {
            fout << ' ';
        }
        //
 
        //fout << ' ' << OAT_time_constrained_load.at(i);
    }
    fout << '\n';
    //
    fout << ODM_information_load.size();
    for(i = 0; i < ODM_information_load.size(); i++){
        fout << ' ' << ODM_information_load.at(i);
    }
    fout << '\n';
    //
    fout << OAT_information_load.size();
    for(i = 0; i < OAT_information_load.size(); i++){
        fout << ' ' << OAT_information_load.at(i);
    }
    fout << '\n';
    //
}
void KeyParameterHistoryUnit::retrieveKeyParameterHistoryUnitFromFile(ifstream &fin){
    int i, num;
    int i_value;
    double d_value;
    fin >> current_time;
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        parameter_value_array.push_back(d_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        parameter_trend_array.push_back(d_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> i_value;
        component_state_array.push_back(i_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        mesh_point_value_array.push_back(d_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> i_value;
        alarm_parameter_value_array.push_back(i_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> i_value;
        alarm_component_state_array.push_back(i_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> i_value;
        alarm_value_difference_array.push_back(i_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> i_value;
        control_state_array.push_back(i_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        control_value_array.push_back(d_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        ODM_hardwiredKB_confidence.push_back(d_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        OAT_hardwiredKB_confidence.push_back(d_value);
    }
    //------------
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        ODM_symptom_confidence.push_back(d_value);
    }
    //------------
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        OAT_symptom_confidence.push_back(d_value);
    }
    //------------
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        ODM_event_confidence.push_back(d_value);
    }
    //------------
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        OAT_event_confidence.push_back(d_value);
    }
    //------------
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        ODM_event_lower_bound.push_back(d_value);
    }
    //------------
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        OAT_event_lower_bound.push_back(d_value);
    }
    //------------
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        ODM_event_upper_bound.push_back(d_value);
    }
    //------------
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        OAT_event_upper_bound.push_back(d_value);
    }
//  
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        ODM_safety_parameters.push_back(d_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        OAT_safety_parameters.push_back(d_value);
    }
//  
//  fin >> num;
//  for(i = 0; i < num; i++){
//      fin >> d_value;
//      ODM_RelapPIFs.push_back(d_value);
//  }
//  fin >> num;
//  for(i = 0; i < num; i++){
//      fin >> d_value;
//      OAT_RelapPIFs.push_back(d_value);
//  }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        ODM_time_constrained_load.push_back(d_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        OAT_time_constrained_load.push_back(d_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        ODM_information_load.push_back(d_value);
    }
    fin >> num;
    for(i = 0; i < num; i++){
        fin >> d_value;
        OAT_information_load.push_back(d_value);
    }
}