BranchCluster.cpp

Go to the documentation of this file.

// BranchCluster.cpp: implementation of the BranchCluster class.
//
#if defined(_WIN32)
#include <direct.h>
#include <boost/serialization/export.hpp>
#else
#include <sys/stat.h>
#include <sys/types.h>
#endif
 
#include "BranchCluster.h"
#include "BranchRecord.h"
#include "../Scheduler/Scheduler.h"
#include <filesystem>
#include <functional>
#include <sstream>
#include "../Global/SimulationContext.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include "../Global/PEOutput.h"
BOOST_CLASS_EXPORT_IMPLEMENT(BranchCluster)
using namespace std;
 
namespace fs = std::filesystem;
 
 
// Construction/Destruction
 
BranchCluster::BranchCluster()
{
//  ID_of_the_mother_branch = -1;
    ID_of_the_mother_branch = 0;
    Current_branch_num = -1; //the current branch in the run time
    ID_of_this_branch_cluster = -1;
    n_count_for_restart_RELAP5 = -1;
//  ID_of_the_mother_cluster = -1;
    ID_of_the_mother_cluster = 0;
}
 
BranchCluster::~BranchCluster()
{
    this->clearBranchCluster();
}
void BranchCluster::clearBranchCluster(){
    all_branch.clear();
}
int BranchCluster::getCurrentBranchNum(){return Current_branch_num;}
void BranchCluster::setCurrentBranchNum(int n){Current_branch_num = n;}
 
void BranchCluster::calBranchProbability()
{
    for(auto &p : all_branch){
        p->calculateProbability();
    }
}
 
// Writes one PE node per branch of this cluster under the PE directory strDirName.
void BranchCluster::savePENodeToFile(string strDirName)
{
    int num_subfolder, branch_no, branch_no1, num_of_child;
    string full_file_name, branch_name;
    BranchProbability *current_branch_pt;
//
    //do the following for all branches within this branch cluster
    //Note: each branchProbability within a branchCluster is a PE node
    for(branch_no = 0; branch_no < this->all_branch.size(); branch_no++){
        current_branch_pt = this->all_branch.at(branch_no).get();//each element within all_branch is a PE Node
 
        // The node's content is built in memory first. MPI clients re-save the
        // whole lineage after every sequence, so nearly every file is a
        // byte-identical rewrite. The write is skipped when this process has
        // already put identical bytes on disk for this PE id; the final disk
        // state is the same because any content change (new child link, type
        // flip) changes the signature.
        std::ostringstream oss;
        //
        branch_name = "PE_";
        branch_name += to_string(current_branch_pt->getIDOfThisBranch());
        //TNode
        oss << branch_name << ' ' //Name
            << this->getTimeAtWhichThisEventHappen() << ' '  //Time
            <<  current_branch_pt->getIDOfThisBranch() << ' '//ID
            << this->getIDOfTheMotherBranch() << " 0 " //Mother ID & level
            << sim::Branch::Branch << ' ' << current_branch_pt->getIDOfThisBranch() << ' ' //Type & Type Sequence
            << this->getProbability() << "\n PE_BRANCH " //node probability & node type
            << this->all_branch.size() << ' ' //total branch no
            << branch_no << ' ' << this->getIDOfTheMotherBranch() << " 0 " //current branch no, mother branch no & Child Info ID
            <<  this->all_branch.at(0)->getIDOfThisBranch() << '\n'; //First Sibling sequence
 
        if(current_branch_pt->getTypeOfChild() == sim::Branch::Branch){
            //info of children
            num_of_child = current_branch_pt->child_IDs.size();
            oss << num_of_child << ' ';
 
            for(branch_no1 = 0; branch_no1 < num_of_child; branch_no1++){
                oss << sim::Branch::Branch << ' ';
            }
            oss << '\n';
            oss << num_of_child << ' ';
            for(branch_no1 = 0; branch_no1 < num_of_child; branch_no1++){
                oss << current_branch_pt->child_IDs.at(branch_no1) << ' ';
            }
            oss << '\n';
            //info of current branch cluster
            if (branch_no == 0){
                oss << this->all_branch.size() << ' ';
                for(branch_no1 = 0; branch_no1 < this->all_branch.size(); branch_no1++){
                    oss << this->all_branch.at(branch_no1)->getProbability() << ' ';
                }
                oss << '\n' << this->all_branch.size() << '\n';
                for(branch_no1 = 0; branch_no1 < this->all_branch.size(); branch_no1++){
                    this->all_branch.at(branch_no1)->saveInfoToFile(oss);
                    oss << '\n';
                }
            }
            else{
                oss << "0\n0\n";
            }
        }
        else{//sim::Branch::EndState
            //info of children
            oss << "1 " << sim::Branch::EndState << '\n';
            oss << "1 " << current_branch_pt->getIDOfTheChildBranchCluster() << '\n';
            if (branch_no == 0){
                oss << this->all_branch.size() << ' ';
                for(branch_no1 = 0; branch_no1 < this->all_branch.size(); branch_no1++){
                    oss << this->all_branch.at(branch_no1)->getProbability() << ' ';
                }
                oss << '\n' << this->all_branch.size() << '\n';
                for(branch_no1 = 0; branch_no1 < this->all_branch.size(); branch_no1++){
                    this->all_branch.at(branch_no1)->saveInfoToFile(oss);
                    oss << '\n';
                }
            }
            else{
                oss << "0\n0\n";
            }
        }
 
        const std::string content = oss.str();
        const std::pair<size_t, size_t> sig{content.size(), std::hash<std::string>{}(content)};
        auto [state_it, first_write] = g_sim.pe_file_state.try_emplace(current_branch_pt->getIDOfThisBranch(), sig);
        if (!first_write) {
            if (state_it->second == sig) continue; // identical bytes already on disk
            state_it->second = sig;
        }
 
        // Aggregate layout: one record appended to one file per rank, instead
        // of one file per node. Opt-in; see Global/PEOutput.h for why (file
        // COUNT quota, not capacity, is what bounds a long-mission DET).
        if (g_sim.config.aggregate_pe_output) {
            adsidac::pe::append_record(strDirName,
                current_branch_pt->getIDOfThisBranch(), content);
            continue;
        }
 
        full_file_name = strDirName;
        full_file_name += "PEFolder_";
        num_subfolder = (int) current_branch_pt->getIDOfThisBranch() / g_sim.Branch_center.getSizeOfSubFolder();
        full_file_name += to_string(num_subfolder);
#if defined(_WIN32)
        _mkdir(full_file_name.c_str());
#else
        // Creating a directory
        if (fs::create_directories(full_file_name.c_str()) == -1)
            cerr << "Error :  " << strerror(errno) << endl;
 
#endif
        full_file_name += "//ZPENode_";
        full_file_name += to_string(current_branch_pt->getIDOfThisBranch());
        full_file_name += ".txt";
        ofstream fout(full_file_name.c_str(), ios::out);
        fout << content;
        fout.close();
    }
}
 
 
void BranchCluster::savePENodeToFile(){
    string full_file_name;
    full_file_name = g_sim.SScheduler.getPEDirectory();
 
    savePENodeToFile(full_file_name);
}
 
/*void BranchCluster::saveInfoToFile(){
    ofstream *fout;
    bool first_branch = true;
    int num_subfolder, branch_no;
    char numtext[20];
    string full_file_name, branch_name;
    vector<BranchProbability *>::iterator all_branch_itr, all_branch_itr1; 
    for(all_branch_itr = this->all_branch.begin(); all_branch_itr != this->all_branch.end(); all_branch_itr++){
        itoa((*all_branch_itr)->getIDOfThisBranch(), numtext, 10);
//
        full_file_name = g_sim.SScheduler.getPEDirectory();
        full_file_name += "PEFolder_";
        num_subfolder = (int) (*all_branch_itr)->getIDOfThisBranch() / g_sim.Branch_center.getSizeOfSubFolder();
        itoa(num_subfolder, numtext, 10);
        full_file_name += numtext;
        _mkdir(full_file_name.c_str());
        full_file_name += "//PE_";
        itoa((*all_branch_itr)->getIDOfThisBranch(), numtext, 10);
        full_file_name += numtext;
        full_file_name += ".txt";
        fout = new ofstream();
        fout->open(full_file_name.c_str(), ios::out);
        //
        branch_name = "PE_";
        branch_name += numtext;
        branch_no = 0;
        //TNode
        *fout << branch_name << ' ' //Name 
            << this->getTimeAtWhichThisEventHappen() << ' ' //Time
            <<  (*all_branch_itr)->getIDOfThisBranch() << ' ' //ID
            << this->getIDOfThisBranchCluster() << " 0 " //Mother ID and Level
            << sim::Branch::Branch << ' ' //Type
            << (*all_branch_itr)->getIDOfThisBranch() //Type Sequence
            << ' ' << this->getProbability() //Node probability
            << " PE_BRANCH " << this->all_branch.size() //Node Type and Total branch num
            << " 0 " << branch_no << " 0 " //current branch num, mother branch num, child info ID
            <<  (*all_branch_itr)->getIDOfThisBranch() << ' '
            << this->all_branch.size() << '\n';
 
    
      for(all_branch_itr1 = this->all_branch.begin(); all_branch_itr1 != this->all_branch.end(); all_branch_itr1++){
            *fout << (*all_branch_itr1)->getTypeOfChild << ' ';
        }
        *fout << '\n' << this->all_branch.size() << '\n';
        for(all_branch_itr1 = this->all_branch.begin(); all_branch_itr1 != this->all_branch.end(); all_branch_itr1++){
            *fout << (*all_branch_itr1)->getIDOfThisBranch() << ' ';
        }
        *fout << '\n' << this->all_branch.size() << '\n';
        for(all_branch_itr1 = this->all_branch.begin(); all_branch_itr1 != this->all_branch.end(); all_branch_itr1++){
            *fout << (*all_branch_itr1)->getProbability() << ' ';
        }
        *fout << this->all_branch.size() << '\n';
        for(all_branch_itr1 = this->all_branch.begin(); all_branch_itr1 != this->all_branch.end(); all_branch_itr1++){
 
            *fout << (*all_branch_itr1)->getProbability() << ' ';
        }
        (*all_branch_itr)->saveInfoToFile(*fout);
        //
        branch_no++;
        fout->close();
        delete fout;
    }
}*/
 
void BranchCluster::retrieveInfoFromFile(ifstream &fin){
}
void BranchCluster::setIDOfTheMotherBranch(int n){ID_of_the_mother_branch = n;}
int BranchCluster::getIDOfTheMotherBranch(){return ID_of_the_mother_branch;}
void BranchCluster::setIDOfThisBranchCluster(int n){ID_of_this_branch_cluster = n;}
int BranchCluster::getIDOfThisBranchCluster(){return ID_of_this_branch_cluster;}
void BranchCluster::setNCountForRestartRELAP5(long n){n_count_for_restart_RELAP5 = n;}
int BranchCluster::getNCountForRestartRELAP5(){return n_count_for_restart_RELAP5;}
BranchProbability *BranchCluster::findBranch(int _id){
    bool found = false;
    BranchProbability *branch_pt = 0;
    auto all_branch_ritr = all_branch.rbegin();
    while(all_branch_ritr != all_branch.rend() && !found){
        if((*all_branch_ritr)->getIDOfThisBranch() == _id){
            found = true;
            branch_pt = all_branch_ritr->get();
        }
        all_branch_ritr++;
    }
    if(!found){
    ofstream fout("err messages.txt", ios::app);
    cout << r5pars_.timesno << "\tBranchProbability* BranchCluster::findBranch Branch_ID:" << _id 
        << " could not be found in the BranchCluster: " << this->getIDOfThisBranchCluster() << endl;
    fout << r5pars_.timesno << "\tBranchProbability* BranchCluster::findBranch Branch_ID:" << _id 
        << " could not be found in the BranchCluster: " << this->getIDOfThisBranchCluster() << '\n'; 
    fout.close();
    }
    return branch_pt;
}
void BranchCluster::saveBranchClusterToFile(ofstream &fout){
    int i, num;
    num = this->all_branch.size();
    fout << ID_of_the_mother_branch << ' '
        << ID_of_the_mother_cluster << ' '
        << Current_branch_num << ' ' 
        << ID_of_this_branch_cluster << ' '
        << n_count_for_restart_RELAP5 << '\n'
        << num << '\n';
    for(i = 0; i < num; i++){
        this->all_branch.at(i)->saveBranchProbabilityToFile(fout);
    }
    this->saveTimeToFile(fout);
    this->saveProbabilityToFile(fout);
}
void BranchCluster::retrieveBranchClusterFromFile(ifstream &fin){
    int i, num;
    fin >> ID_of_the_mother_branch
        >> ID_of_the_mother_cluster
        >> Current_branch_num
        >> ID_of_this_branch_cluster
        >> n_count_for_restart_RELAP5
        >> num;
    for(i = 0; i < num; i++){
        auto all_branch_pt = make_unique<BranchProbability>();
        all_branch_pt->retrieveBranchProbabilityFromFile(fin);
        this->all_branch.push_back(std::move(all_branch_pt));
    }
    this->retrieveTimeFromFile(fin);
    this->retrieveProbabilityFromFile(fin);
}
void BranchCluster::copyBranchCluster(BranchCluster &_bc){
    for(auto &src : _bc.all_branch){
        auto ab_pt = make_unique<BranchProbability>();
        ab_pt->copyBranchProbability(*src);
        this->all_branch.push_back(std::move(ab_pt));
    }
    ID_of_the_mother_branch = _bc.getIDOfTheMotherBranch();
    ID_of_the_mother_cluster = _bc.getIDOfMotherCluster();
    Current_branch_num = _bc.getCurrentBranchNum(); //the current branch in the run time
    ID_of_this_branch_cluster = _bc.getIDOfThisBranchCluster();
    n_count_for_restart_RELAP5 = _bc.getNCountForRestartRELAP5();
    this->copyProbability(_bc);
    this->copyTime(_bc);
}
void BranchCluster::setIDOfMotherCluster(int n){ID_of_the_mother_cluster = n;}
int BranchCluster::getIDOfMotherCluster(){return ID_of_the_mother_cluster;}