AnalysisInfoContainer.cpp

Go to the documentation of this file.

// AnalysisInfoContainer.cpp: implementation of the AnalysisInfoContainer class.
//
 
#include "AnalysisInfoContainer.h"
#include "../Global/fmodule.h"
#include "../Global/CheckedIO.h"
#include "Scheduler.h"
#include "../Branch/BranchRecord.h"
#include <boost/serialization/export.hpp>
#include "../Global/SimulationContext.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(AnalysisInfoContainer)
using namespace std;
 
 
// Construction/Destruction
 
AnalysisInfoContainer::AnalysisInfoContainer()
{
 
}
 
AnalysisInfoContainer::~AnalysisInfoContainer()
{
    this->clearAnalysisInfoContainerRecord();
}
 
void AnalysisInfoContainer::addProcedureData(AnalysisProcedureDataContainerUnit _apdcu)
{
    auto apd = make_unique<AnalysisProcedureDataContainerUnit>();
    (*apd) = _apdcu;
    this->procedure_step_data.push_back(std::move(apd));
}
 
void AnalysisInfoContainer::addScanQueueData(double _time, int _operator, KBScannedParameters &_kbsp)
{
    int n, priority;
    string str;
    auto asd = make_unique<AnalysisScanDataContainerUnit>();
    asd->setAnalysisScanDataTime(_time);
    asd->setAnalysisScanDataOperator(_operator);
    //
    for (n = 0; n < _kbsp.alarm_scan_list.size(); n++)
    {
        str = _kbsp.alarm_scan_list.at(n)->getInfoName();
        priority = _kbsp.alarm_scan_list.at(n)->getDecision();
        asd->alarm_name.push_back(str);
        asd->alarm_priority.push_back(priority);
    }
    //
    for (n = 0; n < _kbsp.component_scan_list.size(); n++)
    {
        str = _kbsp.component_scan_list.at(n)->getInfoName();
        priority =  _kbsp.component_scan_list.at(n)->getDecision();
        asd->component_name.push_back(str);
        asd->component_priority.push_back(priority);
    }
    //
    for (n = 0; n < _kbsp.support_system_scan_list.size(); n++)
    {
        str = _kbsp.support_system_scan_list.at(n)->getInfoName();
        priority =  _kbsp.support_system_scan_list.at(n)->getDecision();
        asd->support_system_name.push_back(str);
        asd->support_system_priority.push_back(priority);
    }
    //
    for (n = 0; n < _kbsp.parameter_scan_list.size(); n++)
    {
        str = _kbsp.parameter_scan_list.at(n)->getInfoName();
        priority =  _kbsp.parameter_scan_list.at(n)->getDecision();
        asd->parameter_name.push_back(str);
        asd->parameter_priority.push_back(priority);
    }
    scan_data.push_back(std::move(asd));
}
 
void AnalysisInfoContainer::addRecord(string str, int _branch_ID){
    auto aip = make_unique<AnalysisInfoContainerUnit>(r5pars_.timesno, str, _branch_ID);
    record.push_back(std::move(aip));
 
};
 
void AnalysisInfoContainer::saveInfoToFile(string strDirName, int iSeqNum){
    string file_name_record = strDirName;
    string file_name_procedure = strDirName;
    string file_name_scan_data = strDirName;
    file_name_record += "Scenario info.txt";
    file_name_procedure += "Procedure data.txt";
    file_name_scan_data += "Scan data.txt";
 
    ofstream fout(file_name_record.c_str(), ios::app);
    fout << "*********************************************\n"
         << "*** Event Hightlights for Sequence " << iSeqNum  << " ***\n"
         << "*********************************************\n";
    for(auto& ai : record){
        ai->saveInfoToFile(fout);
    }
    checked_close(fout, file_name_record);
 
    ofstream fout1(file_name_procedure.c_str(), ios::app);
    fout1<< "*********************************************\n"
         << "*** Event Hightlights for Sequence " << iSeqNum  << " ***\n"
         << "*********************************************\n";
    // output procedure data units to file
    fout1<< "Time"             << '\t'
         << "Operator"         << '\t'
         << "Procedure"        << '\t'
         << "Step"             << '\t'
         << "Action"           << '\t'
         << "Relevance"        << '\t'
         << "Time_Load_PIF"    << '\t'
         << "Dynamic_Factor"   << '\t'
         << "Static_Factor"    << '\t'
         << "Skip_Probability" << '\n';
    //
    for(auto& apd : this->procedure_step_data){
        apd->saveProcedureDataInfotoFile(fout1);
    }
    checked_close(fout1, file_name_procedure);
    //
    //Output scan queue data to file
    ofstream fout2(file_name_scan_data.c_str(), ios::app);
    fout2<< "*********************************************\n"
         << "*** Event Hightlights for Sequence " << iSeqNum  << " ***\n"
         << "*********************************************\n";
    // output scan data units to file
    fout2<< "Time"             << '\t'
         << "Operator"         << '\t'
         << "Scan Queue Size"  << '\n';
    //
    for(auto& asd : this->scan_data){
        asd->saveScanDataInfotoFile(fout2);
    }
    checked_close(fout2, file_name_scan_data);
}
 
void AnalysisInfoContainer::saveInfoToFile(){
    string file_name = g_sim.SScheduler.getESDirectory();
    saveInfoToFile(file_name, g_sim.Branch_center.getIDOfRecentGeneratedES());
}
 
void AnalysisInfoContainer::clearAnalysisInfoContainerRecord(){
    record.clear();
    this->procedure_step_data.clear();
    this->scan_data.clear();
}
void AnalysisInfoContainer::copyAnalysisInfoContainer(AnalysisInfoContainer &_ai){
    for(auto& src : _ai.record){
        auto record_pt = make_unique<AnalysisInfoContainerUnit>();
        record_pt->copyAnalysisInfoContainerUnit(*src);
        this->record.push_back(std::move(record_pt));
    }
 
    for(auto& src : _ai.procedure_step_data){
        auto procedure_pt = make_unique<AnalysisProcedureDataContainerUnit>();
        procedure_pt->copyAnalysisProcedureDataContainerUnit(*src);
        this->procedure_step_data.push_back(std::move(procedure_pt));
    }
 
    for(auto& src : _ai.scan_data) {
        auto scan_pt = make_unique<AnalysisScanDataContainerUnit>();
        scan_pt->copyAnalysisScanDataContainerUnit(*src);
        this->scan_data.push_back(std::move(scan_pt));
    }
}
void AnalysisInfoContainer::clearAnalysisInfoContainerForRestart(){
    this->clearAnalysisInfoContainerRecord();
}
void AnalysisInfoContainer::copyAnalysisInfoContainerForRestart(AnalysisInfoContainer &_ai){
    this->copyAnalysisInfoContainer(_ai);
}
void AnalysisInfoContainer::addRecordWithTime(double _time, string _str){
    auto aip = make_unique<AnalysisInfoContainerUnit>(_time, _str);
    record.push_back(std::move(aip));
}
void AnalysisInfoContainer::saveAnalysisInfoContainerToFile(ofstream &fout){
    int i, num;
    num = this->record.size();
    fout << "AnalysisInfoContainer\n" << num << '\n';
    for(i = 0; i < num; i++){
        this->record.at(i)->saveAnalysisInfoContainerUnitToFile(fout);
    }
 
    num = this->procedure_step_data.size();
    fout << "AnalysisProcedureDataContainer\n" << num << '\n';
    for(i = 0; i < num; i++){
        this->procedure_step_data.at(i)->saveAnalysisProcedureDataContainerUnittoFile(fout);
    }
 
    num = this->scan_data.size();
    fout << "AnalysisScanDataContainer\n"  << num << '\n';
    for(i = 0; i <num; i++) {
        this->scan_data.at(i)->saveAnalysisScanDataContainerUnittoFile(fout);
    }
 
}
void AnalysisInfoContainer::retrieveAnalysisInfoContainerFromFile(ifstream &fin){
    int i, num;
 
    string str;
    fin >> str >> num;
    if (str != "AnalysisInfoContainer"){
        ofstream fout("err messages.txt", ios::app);
        cout << "AnalysisInfoContainer::retrieveAnalysisInfoContainerFromFile retrieval error in previous function" << endl;
        fout << r5pars_.timesno << "  AnalysisInfoContainer::retrieveAnalysisInfoContainerFromFile retrieval error in previous function\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("AnalysisInfoContainer::retrieveAnalysisInfoContainerFromFile Prior err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
        return;
    }
 
    for(i = 0; i < num; i++){
        auto record_pt = make_unique<AnalysisInfoContainerUnit>();
        record_pt->retrieveAnalysisInfoContainerUnitFromFile(fin);
        this->record.push_back(std::move(record_pt));
    }
 
    fin >> str >> num;
    if (str != "AnalysisProcedureDataContainer"){
        ofstream fout("err messages.txt", ios::app);
        cout << "AnalysisInfoContainer::retrieveAnalysisProcedureContainerFromFile retrieval error in previous function" << endl;
        fout << r5pars_.timesno << "  AnalysisInfoContainer::retrieveAnalysisProcedureContainerFromFile retrieval error in previous function\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("AnalysisInfoContainer::retrieveAnalysisProcedureContainerFromFile Prior err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
        return;
    }
 
    for(i = 0; i< num; i++){
        auto procedure_pt = make_unique<AnalysisProcedureDataContainerUnit>();
        procedure_pt->retrieveAnalysisProcedureDataContainerUnitfromFile(fin);
        this->procedure_step_data.push_back(std::move(procedure_pt));
    }
 
    fin >> str >> num;
    if (str != "AnalysisScanDataContainer"){
        ofstream fout("err messages.txt", ios::app);
        cout << "AnalysisInfoContainer::retrieveAnalysisScanDataContainerFromFile retrieval error in previous function" << endl;
        fout << r5pars_.timesno << "  AnalysisInfoContainer::retrieveAnalysisScanDataContainerFromFile retrieval error in previous function\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("AnalysisInfoContainer::retrieveAnalysisScanDataContainerFromFile Prior err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
        return;
    }
 
    for(i = 0; i< num; i++){
        auto scan_data_pt = make_unique<AnalysisScanDataContainerUnit>();
        scan_data_pt->retrieveAnalysisScanDataContainerUnitfromFile(fin);
        this->scan_data.push_back(std::move(scan_data_pt));
    }
 
}