KnowledgeUnit.cpp

Go to the documentation of this file.

// KnowledgeUnit.cpp: implementation of the KnowledgeUnit class.
//
 
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
 
#include "KnowledgeUnit.h"
#include "ReasonMachine.h"
#include "../Crew/OperatorDM.h"
#include "../Crew/OperatorAT.h"
#include "../Global/SimulationContext.h"
 
using namespace std;
 
 
// Construction/Destruction
 
KnowledgeUnit::KnowledgeUnit()
{
    this->m_ID_Type = 403;
    this->m_Ancestor_pt = NULL;
    this->m_Descendant_pt = NULL;
    this->m_Permission_pt = NULL;
    this->m_ID_anscestor = "";
    this->m_ID_desscendant = "";
    this->m_ID_permission = "";
    this->m_accessable_bl = true;
    this->m_knowledge_strength = 1;
}
 
KnowledgeUnit::~KnowledgeUnit()
{
 
}
 
void KnowledgeUnit::ReadKnowledgeUnitFromInputFile(ifstream &fin)
{
    string str, str1, str_ID;
    string err_mes;
    int v1;
    float f1;
 
    KnowledgeElement * KE_pt;
    KnowledgeNode * KN_pt;
    string ID_name;
    stringstream conv;
 
    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();}
    else
    {}
 
    fin >> str;
    if(str.compare("A_Knowledge_Unit") != 0)
    {
        err_mes = str1 + " is misplaced to a place of A_Knowledge_Unit";
        this->ErrorMessage(err_mes);
        return;
    }
 
    fin >> str >> v1;
    if(str.compare("Causal_Type:") != 0)
    {
        err_mes = "Causal_Type of " + this->m_ID + " is missing in file Knowledge_Unit_Base txt file";
        this->ErrorMessage(err_mes);
        return;
    }
    this->m_causal_type = v1;
 
    fin >> str >> v1;
    if(str.compare("Inference_Type:") != 0)
    {
        err_mes = "Inference_Type of " + this->m_ID + " is missing in file Knowledge_Unit_Base txt file";
        this->ErrorMessage(err_mes);
        return;
    }
    this->m_inference_type = v1;
 
    fin >> str >> f1;
    if(str.compare("Knowledge_Unit_Strength:") != 0)
    {
        err_mes = "Knowledge_Unit_Strength: " + this->m_ID + " is missing in file Knowledge_Unit_Base txt file";
        this->ErrorMessage(err_mes);
        return;
    }
    this->m_knowledge_strength = f1;
 
    fin >> str >> f1;
    if(str.compare("Forward_Retrieve_Rate:") != 0)
    {
        err_mes = "Forward_Retrieve_Rate of " + this->m_ID + " is missing in file Knowledge_Unit_Base txt file";
        this->ErrorMessage(err_mes);
        return;
    }
    this->m_forward_retrieve_weight = f1;
 
    fin >> str >> f1;
    if(str.compare("Backward_Retrieve_Rate:") != 0)
    {
        err_mes = "Backward_Retrieve_Rate of " + this->m_ID + " is missing in file Knowledge_Unit_Base txt file";
        this->ErrorMessage(err_mes);
        return;
    }
    this->m_backward_retrieve_weight = f1;
 
    fin >> str >> f1;
    if(str.compare("Effective_Time_Forward_DeltaT1:") != 0)
    {
        err_mes = "Effective_Time_Forward_DeltaT1 of " + this->m_ID + " is missing in file Knowledge_Unit_Base txt file";
        this->ErrorMessage(err_mes);
        return;
    }
    this->m_deltaT1 = f1;
 
    fin >> str >> f1;
    if(str.compare("Effective_Time_Backward_DeltaT2:") != 0)
    {
        err_mes = "Effective_Time_Backward_DeltaT2 of " + this->m_ID + " is missing in file Knowledge_Unit_Base txt file";
        this->ErrorMessage(err_mes);
        return;
    }
    this->m_deltaT2 = f1;
 
 
    fin >> str >> v1;
    if(str.compare("UpperStream_Type:") != 0)
    {
        err_mes = "UpperStream_Type of " + this->m_ID + " is missing in file Knowledge_Unit_Base txt file";
        this->ErrorMessage(err_mes);
        return;
    }
 
    fin >> str >> str_ID;
    if(str.compare("UpperStream_ID:")!=0)
    {
        err_mes = "UpperStream_ID of " + this->m_ID + " is missing in file Knowledge_Unit_Base txt file";
        this->ErrorMessage(err_mes);
        return;
    }
    if(v1==1)
    {
        //the upperstream is one KE     
        KE_pt = RM_pt->FindKnowledgeElementByID(str_ID);
        if(KE_pt == NULL)
        {
            err_mes = "error in Knowledge_Unit_Base txt file: could not find KE: " + str_ID;
            this->ErrorMessage(err_mes);
            return;
        }
        this->m_Ancestor_pt = (IDElement*)KE_pt;
    }
    else
    {
        //The upperstream is a KnowledgeNode
        KN_pt = RM_pt->FindKNByID(str_ID);  
        if(KN_pt == NULL)
        {
            err_mes = "error in Knowledge_Unit_Base txt file: could not find KN: " + str_ID;
            this->ErrorMessage(err_mes);
            return;
        }
        this->m_Ancestor_pt = (IDElement *)KN_pt;
    }
    
    //add the downstream information
    fin >> str >> str_ID;
    if(str.compare("DownStream_ID:")!=0)
    {
        err_mes = "DownStream_ID of " + this->m_ID + " is missing in file Knowledge_Unit_Base txt file";
        this->ErrorMessage(err_mes);
        return;
    }
    KE_pt = RM_pt->FindKnowledgeElementByID(str_ID);
    if(KE_pt == NULL)
    {
        err_mes = "error in Knowledge_Unit_Base txt file: could not find KE: " + str_ID;
        this->ErrorMessage(err_mes);
        return;
    }
    this->m_Descendant_pt = (IDElement *)KE_pt;
    this->m_ID = this->m_Ancestor_pt->m_ID + "->" + this->m_Descendant_pt->m_ID;
 
    //check whether there is a permission KE
    fin >> str >> v1;
    if(str.compare("Is_There_A_Permission_Condition:")!=0)
    {
        err_mes = "Is_There_A_Permission_Condition of " + this->m_ID + " is missing in file Knowledge_Unit_Base txt file";
        this->ErrorMessage(err_mes);
        return;
    }
 
    if(v1 == 1)
    {
        //Add the permission KnowledgeElement   
        fin >> str >> str_ID;
        if(str.compare("Permission_ID:")!=0)
        {
            err_mes = "Permission_ID of " + this->m_ID + " is missing in file Knowledge_Unit_Base txt file";
            this->ErrorMessage(err_mes);
            return;
        }
        KE_pt = RM_pt->FindKnowledgeElementByID(str_ID);
        if(KE_pt == NULL)
        {
            err_mes = "error in Knowledge_Unit_Base txt file: could not find KE: " + str_ID;
            this->ErrorMessage(err_mes);
            return;
        }
        this->m_Permission_pt = (IDElement *)KE_pt;
    }
}
 
void KnowledgeUnit::ErrorMessage(string str)
{
    cout << r5pars_.timesno << "  " << str << " in KnowledgeUnit.cpp" << '\n';
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
    //r5pars_.terminateall = true;
}
 
void KnowledgeUnit::ConvertKnowledgeLinkInfoToString()
{
    this->m_ID_anscestor = this->m_Ancestor_pt->m_ID;
    this->m_ID_desscendant = this->m_Descendant_pt->m_ID;
    if(this->m_Permission_pt != NULL)
    {
        this->m_ID_permission = this->m_Permission_pt->m_ID;
    }
}
 
void KnowledgeUnit::CopyStaticKnowledgeUnitInfoFromAnother(KnowledgeUnit * _KU_pt)
{
    this->CopyIDElementToRestartInfo((IDElement*) _KU_pt);
    this->m_operator = _KU_pt->m_operator;
    this->m_deltaT1 = _KU_pt->m_deltaT1;
    this->m_deltaT2 = _KU_pt->m_deltaT2;
    this->m_forward_retrieve_weight = _KU_pt->m_forward_retrieve_weight;
    this->m_backward_retrieve_weight = _KU_pt->m_backward_retrieve_weight;
    this->m_causal_type = _KU_pt->m_causal_type;
    this->m_inference_type = _KU_pt->m_inference_type;
    this->m_mechanism_type = _KU_pt->m_mechanism_type;
 
    this->m_ID_anscestor = _KU_pt->m_ID_anscestor;
    this->m_ID_desscendant = _KU_pt->m_ID_desscendant;
    this->m_ID_permission = _KU_pt->m_ID_permission;
 
    this->m_accessable_bl = _KU_pt->m_accessable_bl;
    this->m_knowledge_strength = _KU_pt->m_knowledge_strength;
 
}
 
void KnowledgeUnit::BuildConnectionsToThisKU(void * _pt)
{
    ReasonMachine * RM_pt;
    RM_pt = (ReasonMachine *)_pt;
/*
    string m_ID_desscendant;
    string m_ID_anscestor;
    string m_ID_permission;
 
    IDElement * m_Descendant_pt;
    IDElement * m_Ancestor_pt;  
    IDElement * m_Permission_pt;
*/
    this->m_Descendant_pt = RM_pt->FindKnowledgeElementByID(this->m_ID_desscendant);
    if(this->m_Descendant_pt == NULL)
    {this->ErrorMessage("could not find the descendant of this knowledge unit " + this->m_ID_desscendant); return;}
    
    this->m_Ancestor_pt = RM_pt->FindKnowledgeElementByID(this->m_ID_anscestor);
    if(this->m_Ancestor_pt == NULL)
    {
        this->m_Ancestor_pt = RM_pt->FindKNByID(this->m_ID_anscestor);
        if(this->m_Ancestor_pt == NULL)
        {this->ErrorMessage("could not find the anscestor of this knowledge unit " + this->m_ID_anscestor); return;}
    }
 
    if(this->m_ID_permission.compare("") == 0)
    {return;}
 
    this->m_Permission_pt = RM_pt->FindKnowledgeElementByID(this->m_ID_permission);
    if(this->m_Permission_pt == NULL)
    {
        this->m_Permission_pt = RM_pt->FindKNByID(this->m_ID_permission);
        if(this->m_Permission_pt == NULL)
        {this->ErrorMessage("could not find the permission KE of this knowledge unit " + this->m_ID_permission); return;}
    }
}