KBConcept.cpp

Go to the documentation of this file.

// KBConcept.cpp: implementation of the KBConcept class.
//
 
#include <iostream>
#include <fstream>
#include <algorithm>
#include <math.h>
 
#include "KBConcept.h"
#include "../Scheduler/Scheduler.h"
#include "../Global/TermConversions.h"
#include "ConceptBasicUnit.h"
#include "ConceptComposedUnit.h"
#include "InstantiationBase.h"
#include "../Crew/OperatorDM.h"
#include "../Crew/OperatorAT.h"
#include "../Global/SimulationContext.h"
 
using namespace std;
 
 
// Construction/Destruction
 
KBConcept::KBConcept()
{
    m_decrease_pt = NULL;
    m_increase_pt = NULL;
    m_stable_pt = NULL;
 
    m_ON_pt = NULL;
    m_OFF_pt = NULL;
 
    m_bigger_pt = NULL;
    m_smaller_pt = NULL;
    m_equal_pt = NULL;
 
    m_turn_on_pt = NULL;
    m_turn_off_pt = NULL;
 
    m_open_bigger_pt = NULL;
    m_close_smaller_pt = NULL;
 
}
 
KBConcept::~KBConcept()
{
 
/*
    vector<ConceptBasicUnit *> m_BasicConcept_list;
    vector<ConceptBasicUnit *> m_BasicConcept_updated_list;
    vector<ConceptComposedUnit *> m_ComposedConcept_list;
    vector<ConceptComposedUnit *> m_ComposedConcept_updated_list;
*/
    this->m_BasicConcept_list.clear();
    this->m_ComposedConcept_list.clear();
    this->m_BasicConcept_updated_list.clear();
    this->m_ComposedConcept_updated_list.clear();
 
/*  delete this->m_stable_pt;
    delete this->m_smaller_pt;
    delete this->m_bigger_pt;
    delete this->m_equal_pt;
    delete this->m_close_smaller_pt;
    delete this->m_open_bigger_pt;
    delete this->m_OFF_pt;
    delete this->m_ON_pt;
    delete this->m_turn_off_pt;
    delete this->m_turn_on_pt;
    delete this->m_decrease_pt;
    delete this->m_increase_pt;
*/
 
 
}
 
void KBConcept::ReadKBConceptInfoFromInputFile()
{
        
// to be modified
    string directory, str, str1, str2, str_ID, file_name;
    string err_mes;
    bool found_file;
    ifstream fin;
    ConceptBasicUnit *ConceptBasicUnit_pt;
    ConceptBasicUnit *ConceptBasicUnit_pt1;
    ConceptComposedUnit *ConceptComposedUnit_pt;
    ConceptComposedUnit *ConceptComposedUnit_pt2;
    int i, j, n_Unit, n_type, n_member;
 
    //get the input file directory
    if (this->m_operator == sim::Operator::ODM)
    {file_name = g_sim.SScheduler.getODMDirectory();
    file_name += "RM/";
    file_name += "KB_ODM_Concept_Base.txt";}
    else if (this->m_operator == sim::Operator::OAT)
    {file_name = g_sim.SScheduler.getOATDirectory();
    file_name += "RM/";
    file_name += "KB_OAT_Concept_Base.txt";}
    else
    {
        err_mes = "could not identify the operator in KBConcept::ReadKBConceptInfoFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
    }
    fin.open(file_name.c_str(), ios::in);
    if(!fin.is_open()){//the file contains the list of Calculation Aid cannot be found
        err_mes = "File: " + file_name + " cound not be found";
        this->ErrorMessage(err_mes);
        return;
    }
    else{
 
        //start to read information from the input file
        found_file = true;
        fin >> str >> n_Unit; //read the basic concept unit
        for (i = 0; i < n_Unit; i++){
            fin >> str1 >> str2 >> n_type;
            ConceptBasicUnit_pt1 = checkExistanceOfConceptBasicUnit(str1);
            if (ConceptBasicUnit_pt1 != NULL)
            {
                err_mes = str1 + " already existed";
                this->ErrorMessage(err_mes);
                return;}
            else
                {
                auto basic_owned = std::make_unique<ConceptBasicUnit>();
                basic_owned->m_ID = str1;
                basic_owned->m_content = str2;
                basic_owned->m_concept_type = n_type;
                m_BasicConcept_list.push_back(std::move(basic_owned));
            }
        }
 
        //read the composed concept unit
        fin >> str >> n_Unit;
        //add comparison 
        if(str.compare("No_of_Composed_Concept") != 0)
        {
            err_mes = "format error at No_of_Composed_Concept";
            this->ErrorMessage(err_mes);
        }
        for (i = 0; i < n_Unit; i++)
        {
            //Check whether there is a same ID existing
            fin >> str_ID;
            ConceptBasicUnit_pt = this->checkExistanceOfConceptBasicUnit(str_ID);           
            ConceptComposedUnit_pt = this->checkExistanceOfConceptComposedUnit(str_ID);         
            if ((ConceptBasicUnit_pt != NULL) || (ConceptComposedUnit_pt != NULL))
            {
                err_mes = str_ID + " Already Existed " + "Error location: KBConcept::ReadKBConceptInfoFromInputFile";
                this->ErrorMessage(err_mes);
                return;
            }
            auto composed_owned = std::make_unique<ConceptComposedUnit>();
            ConceptComposedUnit_pt = composed_owned.get();
            ConceptComposedUnit_pt->m_ID = str_ID;
 
            // caution: it can be either a basic concept ID or a composed concept ID
            fin >> str;
            ConceptComposedUnit_pt->m_CoreID_pt = this->FindConceptByID(str);
            if(ConceptComposedUnit_pt->m_CoreID_pt == NULL)
            {
                err_mes = "Core concept of " + str_ID +  ":"  + str + " does not exist";
                this->ErrorMessage(err_mes);
                return;
            }
 
            //More specification concept added
            fin >> n_member;
            for (j = 0; j < n_member; j++){
                fin >> str;
                ConceptBasicUnit_pt = this->checkExistanceOfConceptBasicUnit(str);
                if(ConceptBasicUnit_pt != 0)
                {
                    ConceptComposedUnit_pt->m_Spec_array.push_back((IDElement*)ConceptBasicUnit_pt);
                }
                else
                {
                    ConceptComposedUnit_pt2 = this->checkExistanceOfConceptComposedUnit(str);
                    if (ConceptComposedUnit_pt2 == NULL)
                    {
                        err_mes = "specification concept of " + str_ID +  ":"  + str + " does not exist";
                        this->ErrorMessage(err_mes);                        
                        return;
                    }
                    else{
                        ConceptComposedUnit_pt->m_Spec_array.push_back((IDElement*)ConceptComposedUnit_pt2);
                    }
                }
            }
            this->m_ComposedConcept_list.push_back(std::move(composed_owned));
        }
        fin.close();
    }
}
 
ConceptBasicUnit * KBConcept::checkExistanceOfConceptBasicUnit(string _ID)
{
    for (auto &e : m_BasicConcept_list)
    {
        if (e->m_ID == _ID)
            return e.get();
    }
    return nullptr;
}
 
ConceptComposedUnit * KBConcept::checkExistanceOfConceptComposedUnit(string _ID)
{
    for (auto &e : m_ComposedConcept_list)
    {
        if (e->m_ID == _ID)
            return e.get();
    }
    return nullptr;
}
 
IDElement * KBConcept::getIncreasePt()
{
    if (this->m_increase_pt == 0)
    {
        this->m_increase_pt = this->FindConceptByID("increase");
    }
    if(this->m_increase_pt ==0)
    {}//add error message
    return this->m_increase_pt;
}
 
IDElement * KBConcept::getDecreasePt()
{
    if (this->m_decrease_pt == 0)
    {
        this->m_decrease_pt = this->FindConceptByID("decrease");
    }
    if(this->m_decrease_pt ==0)
    {}//add error message
    return this->m_decrease_pt;
}
 
IDElement * KBConcept::getStablePt()
{
    //if(r5pars_.timesno > 9)
    //{this->ErrorMessage("test");}
    if (this->m_stable_pt == NULL)
    {
        this->m_stable_pt = this->FindConceptByID("stable");
    }
    if(this->m_stable_pt == NULL)
    {
        this->ErrorMessage("this->m_stable_pt == NULL");
    }//add error message
    return this->m_stable_pt;
}
 
IDElement * KBConcept::FindConceptByID(string _ID)
{
    for (auto &e : this->m_BasicConcept_list)
    {
        if (e->m_ID == _ID)
            return static_cast<IDElement *>(e.get());
    }
 
    for (auto &e : this->m_ComposedConcept_list)
    {
        if (e->m_ID == _ID)
            return static_cast<IDElement *>(e.get());
    }
    return nullptr;
}
 
IDElement * KBConcept::getTurnOnPt()
{
    if (this->m_turn_on_pt == 0)
    {
        this->m_turn_on_pt = this->FindConceptByID("turn_on");
    }
    if(this->m_turn_on_pt ==0)
    {}//add error message
    return this->m_turn_on_pt;
 
}
IDElement * KBConcept::getTurnOffPt()
{
    if (this->m_turn_off_pt == 0)
    {
        this->m_turn_off_pt = this->FindConceptByID("turn_off");
    }
    if(this->m_turn_off_pt ==0)
    {}//add error message
    return this->m_turn_off_pt;
 
}
 
IDElement * KBConcept::getONpt()
{
    if (this->m_ON_pt == NULL)
    {
        this->m_ON_pt = this->FindConceptByID("ON");
    }
    if(this->m_ON_pt ==NULL)
    {}//add error message
    return this->m_ON_pt;
}
 
IDElement * KBConcept::getOFFpt()
{
    if (this->m_OFF_pt == 0)
    {
        this->m_OFF_pt = this->FindConceptByID("OFF");
    }
    if(this->m_OFF_pt ==0)
    {}//add error message
    return this->m_OFF_pt;
}
 
IDElement * KBConcept::getOpenBiggerPt()
{
    if (this->m_open_bigger_pt == 0)
    {
        this->m_open_bigger_pt = this->FindConceptByID("open_bigger");
    }
    if(this->m_open_bigger_pt ==0)
    {}//add error message
    return this->m_open_bigger_pt;
}
 
IDElement * KBConcept::getCloseSmallerPt()
{
    if (this->m_close_smaller_pt == 0)
    {
        this->m_close_smaller_pt = this->FindConceptByID("close_smaller");
    }
    if(this->m_close_smaller_pt ==0)
    {}//add error message
    return this->m_close_smaller_pt;
}
 
IDElement * KBConcept::getBiggerPt()
{
    if (this->m_bigger_pt == 0)
    {
        this->m_bigger_pt = this->FindConceptByID(">");
    }
    if(this->m_bigger_pt ==0)
    {}//add error message
    return this->m_bigger_pt;
}
 
IDElement * KBConcept::getSmallerPt()
{
    if (this->m_smaller_pt == 0)
    {
        this->m_smaller_pt = this->FindConceptByID("<");
    }
    if(this->m_smaller_pt ==0)
    {}//add error message
    return this->m_smaller_pt;
}
 
IDElement * KBConcept::getEqualPt()
{
    if (this->m_equal_pt == 0)
    {
        this->m_equal_pt = this->FindConceptByID("=");
    }
    if(this->m_equal_pt ==0)
    {}//add error message
    return this->m_equal_pt;
}
 
 
 
vector<IDElement *> KBConcept::getAntonymList(IDElement *)
{
    //to be added
    vector<IDElement *> antonym_list;
    return antonym_list;
}
 
bool KBConcept::checkWhetherAntonyms(IDElement * _ID1_pt, IDElement * _ID2_pt)
{
    //to be added
    bool IsAntonyms=true;
    return IsAntonyms;
}
 
void KBConcept::ReadAntonymBaseFromInputFile()
{
    string directory, str, str1, file_name, ID_str1, ID_str2;
    string err_mes;
    ifstream fin;
    ConceptBasicUnit *ConceptB_pt1;
    ConceptBasicUnit *ConceptB_pt2;
    ConceptComposedUnit *ConceptC_pt1;
    ConceptComposedUnit *ConceptC_pt2;
    vector<string> antonym_group;
    vector<string>::iterator str_itr1, str_itr2;
    int i, j, n_Unit, n1;
 
    //get the input file directory
    if (this->m_operator == sim::Operator::ODM)
    {file_name = g_sim.SScheduler.getODMDirectory();
    file_name += "RM//";
    file_name += "KB_ODM_Antonym_Base.txt";}
    else if (this->m_operator == sim::Operator::OAT)
    {file_name = g_sim.SScheduler.getOATDirectory();
    file_name += "RM//";
    file_name += "KB_OAT_Antonym_Base.txt";}
    else
    {
        err_mes = "could not identify the operator in KBConcept::ReadAntonymBaseFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
    }
    fin.open(file_name.c_str(), ios::in);
    if(!fin.is_open()){//the file contains the list of Calculation Aid cannot be found
        err_mes = "file: " + file_name + " cound not be found"; 
        this->ErrorMessage(err_mes);
        return;
    }
    else
    {
        //start to read the Antonym Base
        fin >> str >> n_Unit;
        for(i = 0; i<n_Unit; i++)
        {
            fin >> n1;
            //read all the IDs in this group into a vector
            antonym_group.clear();
            for(j = 0; j < n1; j++)
            {
                fin >> str;
                antonym_group.push_back(str);
            }
 
            for(str_itr1 = antonym_group.begin(); str_itr1 != antonym_group.end(); str_itr1++)
            {
                ID_str1 = *str_itr1;
                ConceptB_pt1 = this->checkExistanceOfConceptBasicUnit(ID_str1);
                if(ConceptB_pt1 == NULL)
                {
                    err_mes = "Could not find" + ID_str1 + "Location: KBConcept::ReadAntonymBaseFromInputFile()";
                    this->ErrorMessage(err_mes);
                }
                //add the antonym list to each word
                for(str_itr2 = antonym_group.begin(); str_itr2 != antonym_group.end(); str_itr2++)
                {
                    ID_str2 = *str_itr2;
                    ConceptB_pt2 = this->checkExistanceOfConceptBasicUnit(ID_str2);
                    if(ConceptB_pt2 == NULL)
                    {
                        err_mes = "Could not find" + ID_str2 + "Location: KBConcept::ReadAntonymBaseFromInputFile()";
                        this->ErrorMessage(err_mes);
                    }
                    if(ID_str1 != ID_str2)
                    {
                        ConceptB_pt1->m_antonym_list.push_back((IDElement*)ConceptB_pt2);
                    }
                }// end of for(str_itr2 
            }//end of for(str_itr1
        }
    }
    fin.close();
}
 
void KBConcept::PropagateActivationFromBasicConceptToComposedConcept()
{
    ConceptBasicUnit * B_pt;
    ConceptComposedUnit * C_pt;
    double ratio;
    float n;
    for (auto B_itr = this->m_BasicConcept_updated_list.begin(); B_itr!=this->m_BasicConcept_updated_list.end(); B_itr++)
    {
        B_pt = *B_itr;
        for (auto &e : this->m_ComposedConcept_list)
        {
            C_pt = e.get();
            if(C_pt->CheckWhetherContainThisConceptDirectly((IDElement *)B_pt) == true)
            {
                n = 1 + C_pt->m_Spec_array.size();
                ratio = pow(B_pt->m_change_ratio, float(1/n));
                C_pt->ChangeActivationByRatio(ratio);
                if(this->CheckExistingInConceptComposedUnitUpdateList(C_pt) == false)
                {this->m_ComposedConcept_updated_list.push_back(C_pt);}
            }
        }
    }
 
}
 
//DEL void KBConcept::PropagateActivationFromComposedConceptToBasicConcept()
//DEL {
//DEL 
//DEL }
 
void KBConcept::ActivationDecayOfConcept(double _lamda)
{
    for (auto &e : this->m_BasicConcept_list)
    {
        e->ActivationDecay(_lamda);
    }
 
    for (auto &e : this->m_ComposedConcept_list)
    {
        e->ActivationDecay(_lamda);
    }
}
 
void KBConcept::PropagateActivationAmongComposedConceptBottomUp()
{
    //known limitation of this subroutine: if a->b, a->c, b->c, activation propagating from c might be double counted.
    ConceptComposedUnit * C_pt1;
    ConceptComposedUnit * C_pt2;
    float ratio;
    float n;
    auto C_itr1 = this->m_ComposedConcept_updated_list.begin();
    while(C_itr1 != this->m_ComposedConcept_updated_list.end())
    {
        C_pt1 = *C_itr1;
        for (auto &e : this->m_ComposedConcept_list)
        {
            C_pt2 = e.get();
            if(C_pt2->CheckWhetherContainThisConceptDirectly((IDElement *)C_pt1) == true)
            {
                //update the activation of C_pt2
                n = 1 + C_pt2->m_Spec_array.size();
                ratio = pow(C_pt1->m_change_ratio, float(1/n));
                C_pt2->ChangeActivationByRatio(ratio);
                if(this->CheckExistingInConceptComposedUnitUpdateList(C_pt2) == false)
                {this->m_ComposedConcept_updated_list.push_back(C_pt2);}
            }
        }
        //finish propagation from C_pt1
        C_itr1= this->m_ComposedConcept_updated_list.begin();
        (*C_itr1)->ResetChangeRatio();
        this->m_ComposedConcept_updated_list.erase(C_itr1);
    }
}
 
void KBConcept::PropagateActivationAmongConceptsTopDown()
{
    ConceptComposedUnit * C_pt;
    IDElement * ID_pt;
    vector<ConceptComposedUnit *>::iterator C_itr;
    vector<IDElement *>::iterator ID_itr;
    float n;
    double ratio1, ratio2;
 
    //for(C_itr = this->m_ComposedConcept_updated_list.begin(); C_itr != this->m_ComposedConcept_updated_list.end(); C_itr++)
    while(this->m_ComposedConcept_updated_list.size() != 0)
    {
        C_itr = this->m_ComposedConcept_updated_list.begin();
        C_pt = *C_itr;
        n = 1 +C_pt->m_Spec_array.size();
        ratio1 = C_pt->m_change_ratio;
        ratio2 = pow(ratio1, float(1/n));
        ID_pt = C_pt->m_CoreID_pt;
        this->ChangeActivationByConceptID(ID_pt, ratio2);
        for(ID_itr = C_pt->m_Spec_array.begin(); ID_itr != C_pt->m_Spec_array.end(); ID_itr++)
        {
            ID_pt = *ID_itr;
            this->ChangeActivationByConceptID(ID_pt, ratio2);
        }       
        C_itr = this->m_ComposedConcept_updated_list.begin();
        (*C_itr)->ResetChangeRatio();
        this->m_ComposedConcept_updated_list.erase(C_itr);
        //C_itr--;
    }
}
 
bool KBConcept::CheckExistingInConceptBasicUnitUpdateList(ConceptBasicUnit * _B_pt)
{
    vector<ConceptBasicUnit *>::iterator B_itr;
    bool exist = false;
    for(B_itr = this->m_BasicConcept_updated_list.begin(); B_itr!= this->m_BasicConcept_updated_list.end() && exist == false; B_itr++)
    {
        if((*B_itr) == _B_pt)
        {exist = true;}
    }
    return exist;
}
 
bool KBConcept::CheckExistingInConceptComposedUnitUpdateList(ConceptComposedUnit * _C_pt)
{
    vector<ConceptComposedUnit *>::iterator C_itr;
    bool exist = false;
 
    for(C_itr = this->m_ComposedConcept_updated_list.begin(); C_itr != this->m_ComposedConcept_updated_list.end() && exist == false;C_itr++)
    {
        if((*C_itr) == _C_pt)
        {exist = true;}
    }
    return exist;
 
}
 
void KBConcept::ChangeActivationByConceptID(IDElement * _ID_pt, double _ratio)
{
    ConceptBasicUnit * B_pt;
    ConceptComposedUnit * C_pt;
    IDElement * ID_pt;  
 
    switch (_ID_pt->m_ID_Type)
    {
    case 1:
        B_pt = (ConceptBasicUnit *)_ID_pt;
        B_pt->ChangeActivationByRatio(_ratio);
        if(this->CheckExistingInConceptBasicUnitUpdateList(B_pt) == false)
        {this->m_BasicConcept_updated_list.push_back(B_pt);}
        break;
    case 2:
        C_pt = (ConceptComposedUnit *)_ID_pt;
        C_pt->ChangeActivationByRatio(_ratio);
        if(this->CheckExistingInConceptComposedUnitUpdateList(C_pt) == false)
        {this->m_ComposedConcept_updated_list.push_back(C_pt);}
        break;
    default:
        //error message
        break;
    }
}
 
void KBConcept::CleanConceptBasicUnitUpdateList()
{
    // clean update list of basic concept
    vector<ConceptBasicUnit *>::iterator B_itr;
    B_itr = this->m_BasicConcept_updated_list.begin();
    while( B_itr != this->m_BasicConcept_updated_list.end())
    {
        this->m_BasicConcept_updated_list.erase(B_itr);
    }
}
 
void KBConcept::CleanConceptComposedUnitUpdateList()
{
    //clean update list of composed concept
    vector<ConceptComposedUnit *>::iterator C_itr;
    C_itr = this->m_ComposedConcept_updated_list.begin();
    while( C_itr != this->m_ComposedConcept_updated_list.end())
    {
        this->m_ComposedConcept_updated_list.erase(C_itr);
    }
}
 
void KBConcept::SetActivationChangeOfConceptBasicUnitsBackToOne()
{
    //reset activation change of basic concept
    for (auto &e : this->m_BasicConcept_list)
    {
        e->m_change_ratio = 1;
    }
}
 
void KBConcept::SetActivationChangeOfConceptComposedUnitsBackToOne()
{
    //reset activation change of composed concept
    for (auto &e : this->m_ComposedConcept_list)
    {
        e->m_change_ratio = 1;
    }
}
 
void KBConcept::SetAllConceptActivationChangeBackToOneAndCleanTheUpdateList()
{
    this->SetActivationChangeOfConceptBasicUnitsBackToOne();
    this->SetActivationChangeOfConceptComposedUnitsBackToOne();
    this->CleanConceptBasicUnitUpdateList();
    this->CleanConceptComposedUnitUpdateList();
}
 
void KBConcept::FillTheConceptCompsedUnitUpdateList()
{
    //find out those composed concepts with activation_change bigger than 1 and push them to the list
    this->m_ComposedConcept_updated_list.clear();
    for (auto &e : this->m_ComposedConcept_list)
    {
        if(e->m_activation != e->m_old_activation)
        {
            e->UpdateChangeRatio();
            this->m_ComposedConcept_updated_list.push_back(e.get());
        }
    }
}
 
void KBConcept::ErrorMessage(string str)
{
    cout << r5pars_.timesno << "  " << str << " in KBConcept.cpp" << '\n';
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
    //r5pars_.terminateall = true;
}
 
IDElement * KBConcept::CheckExistanceOfConcept(string str_ID)
{
    IDElement * ID_pt = NULL;
    ID_pt = this->checkExistanceOfConceptBasicUnit(str_ID);
    if(ID_pt == NULL)
    {
        ID_pt = this->checkExistanceOfConceptComposedUnit(str_ID);
    }
    return ID_pt;
}
 
void KBConcept::CopyStaticKBConceptFromAnother(KBConcept * _CB_pt)
{
    //Save the Basic concept base first
    IDElement * ID_pt;
    ConceptBasicUnit * BC_pt;
    ConceptComposedUnit * CC_pt;
    KBConceptBaseDataSetUnit * data_pt;
 
 
    this->m_operator = _CB_pt->m_operator;
    if(this->m_BasicConcept_list.size() != 0)
    {
        this->ErrorMessage("The Basic Concept List is not empty and not ready for the copy action!");
    }
    for (auto &e : _CB_pt->m_BasicConcept_list)
    {
        auto bc_owned = std::make_unique<ConceptBasicUnit>();
        bc_owned->CopyConceptBasicUnitToRestartInfo(e.get());
        this->m_BasicConcept_list.push_back(std::move(bc_owned));
    }
 
    //Save the Composed Concept Base
 
    if(this->m_ComposedConcept_list.size() != 0)
    {
        this->ErrorMessage("The Composit Concept List is not empty and not ready for the copy action!");
    }
    for (auto &e : _CB_pt->m_ComposedConcept_list)
    {
        //to be continued
        auto cc_owned = std::make_unique<ConceptComposedUnit>();
        cc_owned->CopyInfoFromAnotherConceptComposedUnit(e.get());
        this->m_ComposedConcept_list.push_back(std::move(cc_owned));
    }
 
    //copy the dataset
    if(this->m_data_array.size() != 0)
    {
        this->ErrorMessage("The data array is not empty at the begining!");
    }
 
    for (auto &e : this->m_data_array)
    {
        auto data_owned = std::make_unique<KBConceptBaseDataSetUnit>();
        data_owned->CopyFromAnotherKBConceptBaseDataSetUnit(e.get());
    }
}
 
//DEL void KBConcept::MakeConnectionAmongConceptBasicConcept()
//DEL {
//DEL   //to be added
//DEL }
 
void KBConcept::ReconstructThePointerLinks(void * _RM_pt)
{
    vector<string >::iterator ID_itr;
    IDElement * ID_pt;
    ConceptBasicUnit * BC_pt;
    ConceptComposedUnit * CC_pt;
    ReasonMachine * RM_pt;
 
    RM_pt = (ReasonMachine *)_RM_pt;
 
    for (auto &e : this->m_BasicConcept_list)
    {
        BC_pt = e.get();
        if(BC_pt->m_antonym_list.size() != 0)
        {
            this->ErrorMessage("Problem with reconstructing the antonym pointers");
        }
        for(ID_itr = BC_pt->m_antonym_ID_list.begin(); ID_itr != BC_pt->m_antonym_ID_list.end(); ID_itr++)
        {
            ID_pt = this->CheckExistanceOfConcept(*ID_itr);
            if(ID_pt == NULL)
            {
                this->ErrorMessage("could not find the antonym concept " + (*ID_itr));
            }
            else
            {
                BC_pt->m_antonym_list.push_back(ID_pt);
            }
        }
    }
    //establish the pointers in the ConceptComposedUnit
    for (auto &e : this->m_ComposedConcept_list)
    {
        CC_pt = e.get();
        //establish the core concept pointer
        ID_pt = this->CheckExistanceOfConcept(CC_pt->m_ID_core);
        if(ID_pt == NULL)
        {
            this->ErrorMessage("Could not find the core concept "+ CC_pt->m_ID_core + " of " + CC_pt->m_ID);
        }
        else
        {
            CC_pt->m_CoreID_pt = ID_pt;
        }
        //establish the specification concept pointers;
        for(ID_itr = CC_pt->m_ID_spec_list.begin(); ID_itr != CC_pt->m_ID_spec_list.end(); ID_itr++)
        {
            ID_pt = this->CheckExistanceOfConcept(*ID_itr);
            if(ID_pt == NULL)
            {
                this->ErrorMessage("could not find the antonym concept " + (*ID_itr));
            }
            else
            {
                CC_pt->m_Spec_array.push_back(ID_pt);
            }
        }
        //establish antonym pointers
        if(CC_pt->m_antonym_list.size() != 0)
        {
            this->ErrorMessage("Problem with reconstructing the antonym pointers");
        }
        for(ID_itr = CC_pt->m_ID_antonym_list.begin(); ID_itr != CC_pt->m_ID_antonym_list.end(); ID_itr++)
        {
            ID_pt = this->CheckExistanceOfConcept(*ID_itr);
            if(ID_pt == NULL)
            {
                this->ErrorMessage("could not find the antonym concept " + (*ID_itr));
            }
            else
            {
                CC_pt->m_antonym_list.push_back(ID_pt);
            }
        }
        //add the indefinite concept pointer
        if(CC_pt->m_ID_indefinite.compare("") != 0)
        {
            ID_pt = this->CheckExistanceOfConcept(CC_pt->m_ID_indefinite);
            if(ID_pt == NULL)
            {
                this->ErrorMessage("Could not find the indefinite concept " + CC_pt->m_ID_indefinite + " for " + CC_pt->m_ID);
            }
            else
            {
                CC_pt->m_Indefinite_Concept_ID_pt = ID_pt;
            }
        }
        //add the label pointer
        if(CC_pt->m_ID_lable.compare("") != 0)
        {
            CC_pt->m_label_ID_pt  = (IDElement *)(RM_pt->m_IB->CheckExistanceOfLabelGroupByName(CC_pt->m_ID_lable));
            if(CC_pt->m_label_ID_pt == NULL)
            {
                this->ErrorMessage("Could not find the corresponding label for the concept " + CC_pt->m_ID);
            }
        }
    }
 
}
 
void KBConcept::ConvertConnectionToStringForm()
{
    for (auto &e : this->m_ComposedConcept_list)
    {
        e->ConvertPointerConnectionToStringForm();
    }
 
}
 
void KBConcept::BuidConnectionsWithinKBConcept()
{
    vector<string>::iterator str_itr;
    ConceptBasicUnit * cb_pt;
    ConceptComposedUnit * cc_pt;
    ReasonMachine * RM_pt;
    if(this->m_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if(this->m_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
 
    IDElement * ID_pt;
 
    for (auto &e : this->m_BasicConcept_list)
    {
        cb_pt = e.get();
        for(str_itr = cb_pt->m_antonym_ID_list.begin(); str_itr != cb_pt->m_antonym_ID_list.end(); str_itr++)
        {
            ID_pt = this->FindConceptByID(*str_itr);
            if(ID_pt == NULL)
            {this->ErrorMessage("could not find BasicConceptUnit " + *str_itr);return;}
            cb_pt->m_antonym_list.push_back(ID_pt);
        }
    }
/*
    IDElement * m_CoreID_pt;
    IDElement * m_label_ID_pt;
    IDElement * m_Indefinite_Concept_ID_pt;
 
    string m_ID_core;
    string m_ID_indefinite;
    string m_ID_lable;
 
    vector<IDElement *> m_Spec_array;
    vector<IDElement *> m_antonym_list;
 
    vector<string> m_ID_spec_list;
    vector<string> m_ID_antonym_list;
*/
    for (auto &e : this->m_ComposedConcept_list)
    {
        cc_pt = e.get();
        cc_pt->m_CoreID_pt = this->FindConceptByID(cc_pt->m_ID_core);
        if(cc_pt->m_CoreID_pt == NULL)
        {this->ErrorMessage("could not find the core concept " + cc_pt->m_ID_core);return;}
 
        if(cc_pt->m_ID_indefinite.compare("") != 0)
        {
            cc_pt->m_Indefinite_Concept_ID_pt = this->FindConceptByID(cc_pt->m_ID_indefinite);
            if(cc_pt->m_Indefinite_Concept_ID_pt == NULL)
            {this->ErrorMessage("could not find the indefinite concept " + cc_pt->m_ID_indefinite);return;}
        }
 
        if(cc_pt->m_ID_lable.compare("") != 0)
        {
            cc_pt->m_label_ID_pt  = (IDElement *)(this->FindConceptByID(cc_pt->m_ID_lable));
            if(cc_pt->m_label_ID_pt == NULL)
            {this->ErrorMessage("could not find the label " + cc_pt->m_ID_lable);return;}
        }
 
        for(str_itr = cc_pt->m_ID_antonym_list.begin(); str_itr != cc_pt->m_ID_antonym_list.end(); str_itr++)
        {
            ID_pt = this->FindConceptByID(*str_itr);
            if(ID_pt == NULL)
            {this->ErrorMessage("could not find the antonym concept " + *str_itr);return;}
            cc_pt->m_antonym_list.push_back(ID_pt);
        }
 
        for(str_itr = cc_pt->m_ID_spec_list.begin(); str_itr != cc_pt->m_ID_spec_list.end(); str_itr++)
        {
            ID_pt = this->FindConceptByID(*str_itr);
            if(ID_pt == NULL)
            {this->ErrorMessage("could not find the defining concept " + *str_itr);return;}
            cc_pt->m_Spec_array.push_back(ID_pt);
        }
 
    }
}
 
void KBConcept::AddDataSetOfTheConceptBase()
{
    ReasonMachine * RM_pt;
    if(this->m_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if(this->m_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
 
    auto data_owned = std::make_unique<KBConceptBaseDataSetUnit>();
    KBConceptBaseDataSetUnit * data_unit = data_owned.get();
 
    //add concept activation level
    data_unit->m_data_time =  r5pars_.timesno;
    for (auto &e : this->m_BasicConcept_list)
    {
        data_unit->m_value_list.push_back(e->m_activation);
    }
    for (auto &e : this->m_ComposedConcept_list)
    {
        data_unit->m_value_list.push_back(e->m_activation);
    }
    //add sentence activation level
 
    this->m_data_array.push_back(std::move(data_owned));
    for (auto &s : RM_pt->m_Semantic_list)
    {
        data_unit->m_value_list.push_back(s->m_activation);
        data_unit->m_value_list.push_back(s->m_activation_baseline);
    }
 
}
 
void KBConcept::SaveConceptActivationIntoOutputFile(string _path)
{
    vector<float>::iterator fl_itr;
 
    ReasonMachine * RM_pt;
    if(this->m_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if(this->m_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
 
    ofstream fout(_path.c_str(), ios::out);
    fout << this->m_BasicConcept_list.size() + this->m_ComposedConcept_list.size() + 2*RM_pt->m_Semantic_list.size() + 1 << '\t';
    fout << this->m_data_array.size() + 1 << '\n';
 
    fout << "Time" << '\t';
    for (auto &e : this->m_BasicConcept_list)
    {
        fout << e->m_ID << '\t';
    }
 
    for (auto &e : this->m_ComposedConcept_list)
    {
        fout << e->m_ID << '\t';
    }
 
    for (auto &s : RM_pt->m_Semantic_list)
    {
        fout << s->m_ID << '\t';
        fout << s->m_ID + ": base_line" << '\t';
    }
 
    fout << '\n';
 
    for (auto &e : this->m_data_array)
    {
        fout << e->m_data_time << '\t';
        for(fl_itr = e->m_value_list.begin(); fl_itr != e->m_value_list.end(); fl_itr++)
        {
            fout  << (*fl_itr) << '\t';
        }
        fout << '\n';
    }
 
    fout.close();
 
/*  for(info_itr = this->m_investigation_history.begin(); info_itr != this->m_investigation_history.end(); info_itr++)
    {
        fout << (*info_itr)->m_interval_start << '\t';
        fout << (*info_itr)->m_interval_end << '\t';
        for(str_itr = (*info_itr)->m_thought_line_list.begin(); str_itr != (*info_itr)->m_thought_line_list.end(); str_itr++)
        {
            fout << (*str_itr) << '\t';
        }
        fout << '\n';
    }
    
    */
}
 
void KBConcept::SaveActivationToOldActivationVariable()
{
    for (auto &e : this->m_BasicConcept_list)
    {
        e->m_old_activation = e->m_activation;
    }
 
    for (auto &e : this->m_ComposedConcept_list)
    {
        e->m_old_activation = e->m_activation;
    }
}