ReasonMachine.h

Go to the documentation of this file.

#pragma once
 
 
#include <vector>
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <memory>
 
#include "../Global/SimConstants.h"
#include "../Global/TermConversions.h"
#include "KBConcept.h"  // Added by ClassView
#include "SentenceUnit.h"
#include "KnowledgeUnit.h"
#include "KnowledgeElement.h"
#include "../Branch/BranchRecord.h"
#include "../Scheduler/CommunicationPlace.h"
#include "IDElement.h"
#include "Investigator.h"
#include "InvestigatorLink.h"
#include "MentalRepresentation.h"
#include "../Global/fmodule.h"
#include "RoutineMonitor.h" // Added by ClassView
#include "InstantiationBase.h"
#include "EventSchemaBase.h"
#include "DiagnoseInvestigator.h"
#include "PassiveAlarmLoadUnit.h"
#include "../Crew/TimeConstrainedModule.h"
#include "ValueTimeLineUnit.h"
#include "ProximityModel.h"
#include "StringTimeIntervalUnit.h"
 
 
class ReasonMachine {
 public:
  void PrintKnowledgeWeb();
  void RandomlyGenerateKnowledgeBug();
  void AddPSFandManifestationDataSet();
  void UpdateManifestationParameterAtEndOfATimeStep();
  void UpdatePSFAtEndOfATimeStep();
  void AddDeltaToCognitiveLoad(float);
  void AddDeltaToSystemDynamics(float);
  void ReOpenItemWithActivationLevelAboveAGivenValue(float);
  void AddItemToDecayedItemList(IDElement *);
  void RemoveItemFromDecayedItemList(IDElement *);
  std::vector<IDElement *> m_decayed_item_pt_list;
  std::vector<std::string> m_decayed_item_ID_list;
  float m_goofy_start_time;
  void AutoIgnitionOfDecayedInvestigatorInitiatedByActivatingAStatement(Statement *);
  float CheckRemainingTimeForThisStep();
  float m_interuptiveness;
  void NotDoingAnything();
  void AddItemToOngoingItemStack(std::string);
  void EraseFromOngoingItemStack(std::string);
  int m_memory_span;
  float m_attention_span;
  Investigator *FindASimilarOngoingInvestigator(Investigator *);
  Investigator *FindASimilarInvestigatorRecentlyResolved(Investigator *);
  bool FindAMatchingInvestigatorForAStatement(Statement *);
  Statement *FoundASimilarStatementInLast10Seconds(Statement *);
  void CrankASentenceUnitActivationToAGivenValue(SentenceUnit *, float);
  bool WetherAnInvestigationItemBelongsToTheCurrentThoughtLine(IDElement *);
  void WriteAuxInfo(std::string str);
  void SaveThoughtLineHistory(std::string);
  void AddBackToUnresolvedInvestigationPool(Investigator *);
  int FindThePositionInTheThoughtLineHistory(IDElement *);
  int FindThePositionInTheInvestigationHistory(std::string);
  void DecayOfForgottenInvestigator();
  void CheckWhetherTheThoughtLineHasChanged();
  int GetAlarmStateImediately(std::string CP_name);
  int GetAComponentStateImediately(std::string MR_name);
  int GetASupportSystemStateImediately(std::string MR_name);
  float GetAParameterValueImediately(std::string);
  void SavePSFandDynamicParametersToFile(std::string _path);
  void SettingForVagabondStyle();
  void ReadOperatorReasonMachineProfile();
 
  void AddToRMFeedbackStack(IDElement *);
  void SaveInvestigationLinkInfo(std::string);
  void SaveRMHisoty(std::string);
  void ClearThisReasonMachine();
  void ClearTBIListsForRestart();
  IDElement *FindInvestigatorOrLinkByID(std::string);
  InvestigatorLink *FindInvestigatorLinkByID(std::string);
  Investigator *FindInvestigatorByID(std::string);
  void BuildTheConnectionsWithinRM();
  void CopyStaticKNfromAnotherRM(ReasonMachine *);
  void CopyStaticKEfromAnotherRM(ReasonMachine *);
  void CopySemanticInfoFromAnotherSemanticBase(ReasonMachine *);
  void ConvertRMStaticInfoToStringForm();
  void CopyReasonMachineFromAnotherRM(ReasonMachine *);
  void WaitOneStepThereIsOneOrMoreOperatorBranches();
  void ZeroAllTheInterestFromSymptomInvestigator();
  void AddANewDiagnoseInvestigator(DiagnoseInvestigator *_diagnose_invest_pt);
  void SaveInvestigationsToFile(std::string _path);
  void SaveStatementsToFile(std::string _path);
  void SaveSequenceInfoToFile();
  void MakeOneStepInferenceFromAStatement(Statement *);
  void PrintSemanticBase();
  void SetAllSentenceActivationRatioToOne();
  void PrintMessage(std::string);
  void AddANewKnowledgeUnit(KnowledgeUnit *);
  void ErrorMessage(std::string);
  void FirstRoundCheckInterpretation();
  void FirstRoundCheck();
  void ReadKEBaseAndKNFromInputFile();
  void AddNewInvestigatorLink(InvestigatorLink *);
  void RemoveInvestigatorFromUnresolvedPool(Investigator *);
  void ChangeRMTokenValue(int);
  void AddNewInvestigator(Investigator *);
  void AddANewStatement(Statement *);
  void ActivationUpdateByRefreshAStatement(Statement *);
  void CutTheLengthOfAlarmStack();
  void BalanceTimerWithUnconsumedTime();
  void AddConsumptedDeltaT(double);
  void OneRoundActivationSpreadingFromASentence(SentenceUnit *);
  void PropagateActivationFromConceptToSemanticSentence();
  void ActivationDecayofRM();
  void ReadKnowledgeBaseFromInputFile();
  void ReadSemanticSentencesFromInputFile();
  void InitiationOfReasonMachineFromInputFile();
  void EraseItemFromFeedbackStack(IDElement *);
  void OneStepWorkOnSelectedInvestigatorLink3100();
  void OneStepInterpretation20();
  void OneStepWorkOnSelectedInvestigator3000();
  void OneStepPrioritizeInvestigation30();
  void OneStepRoutineMonitor10();
  void OneStepOfReasonMachine();
  void FindCorrespondingStatementWithinTimeRange(SentenceUnit *, int, int);
  void AddOneInvestigatorByStatement(Statement *);
 
  float m_initial_fatigue_level;
  float m_fatigue_level;
  float m_diagnosis_complexity;
  float m_expert_level;
  float m_cognitive_load;
  float m_overall_stress;
 
  float m_cognitive_resource_use;
  float m_system_dynamic_level;
  float m_load_stress_integration_of_time;
  float m_attention_span_base_value;
  float m_memory_span_base_value; //initiate attention span and memory span
  float m_decay_time_base_value; //300
 
  float m_routine_monitor_interval_multiplier;
  float m_decay_time;
 
  //PSF history
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_time_load_history;
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_fatigue_history;
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_diagnosis_complexity_history;
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_cognitive_load_history;
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_stress_history;
 
  //middle variable history
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_cognitive_resouse_use_history;
 
  //manifestation history
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_routine_monitor_interval_multiplier_history;
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_attention_span_history;
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_memory_span_history;
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_decay_time_history;
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_cognitive_time_cost_multiplier_history;
 
  float m_routine_monitor_threshold;
  std::vector<std::string> m_ongoing_item_stack;
 
  std::unique_ptr<StringTimeIntervalUnit> m_current_thought_line_info;
  std::vector<std::unique_ptr<StringTimeIntervalUnit>> m_thought_line_history;
 
  std::unique_ptr<StringTimeIntervalUnit> m_current_investigation_info;
  std::vector<std::unique_ptr<StringTimeIntervalUnit>> m_investigation_history;
 
  float m_ability_of_integrating_evidence;
  std::unique_ptr<ProximityModel> m_proximity;
  ProblemSolvingStyle m_problem_solving_style;
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_max_alarm_length_timeline;
  std::vector<std::unique_ptr<ValueTimeLineUnit>> m_cognitive_time_cost_multiplier_timeline;
 
  //Performance Shaping Factors
  std::unique_ptr<PassiveAlarmLoadUnit> m_passive_alarm_load;
  TimeConstrainedModule *m_time_constraint;  // non-owning: points to Operator member
  float m_cognitive_time_cost_base_multiplier;
  bool m_buffer_used_bl;
  Investigator *m_buffer_invest_pt;
  std::string m_ID_buffer_invest_pt;
 
 
 
  Investigator *FindAMatchInvestigatorByKnowledgeElement(KnowledgeElement *, int, int);
  Statement *CheckWhetherASentenceIsTrueFromMR(SentenceUnit *, int, int);
  Statement *FindRecentStatementBySentence(SentenceUnit *);
  Statement *FindStatementByID(std::string);
  std::string TranslateRMTokenToWords(int);
 
  KnowledgeUnit *FindKnowledgeUnitByID(std::string);
  KnowledgeElement *FindAKEbySentenceAndNegationSign(SentenceUnit *, bool);
  KnowledgeNode *FindKNByID(std::string);
  KnowledgeElement *FindKnowledgeElementByID(std::string);
  KnowledgeElement *FindKnowledgeElementByStatement(Statement *);
 
  SentenceUnit *CheckExistInSemanticPoolBySentence(SentenceUnit *);
  SentenceUnit *SearchSentenceByID(std::string);
  SentenceUnit *InstantiateAnIndefiniteSentenceWithLabel(SentenceUnit *, IDElement *);
  SentenceUnit *FindAnIndefiniteSentenceMatchTheInputSentence(SentenceUnit *);
 
  bool m_leisure_time;
  double m_decay_lamda;
  double m_decay_constant_lamda;
  double m_timer_RM;
  double m_alarm_disruption_time_consumption;
  double m_Interpretation_time_consumption;
  bool m_first_round_check_done;
  int m_operator;
  int m_investigator_link_number;
  int m_max_length_of_alarms_stack;
  int m_RM_Token;
  int m_statement_number;
  int m_investigator_number;
  bool m_block_alarm_jam;
  float m_time_length;
  float m_consumed_time;
 
  float m_cognitive_time_cost_multiplier;
 
  std::unique_ptr<EventSchemaBase> m_event_schema_base;
  std::unique_ptr<InstantiationBase> m_IB;
  Investigator *m_working_on_invest_pt;          // non-owning: cross-ref into pool
  InvestigatorLink *m_working_on_invest_link_pt;  // non-owning: cross-ref into pool
  IDElement *m_reading_indication_ID_pt;          // non-owning: cross-ref into MR
  std::unique_ptr<KBConcept> m_Concept_Base;
  std::unique_ptr<RoutineMonitor> m_routine_monitor;
  std::unique_ptr<MentalRepresentation> m_MR;
 
  std::string m_ID_working_on_invest;
  std::string m_ID_working_on_invest_link;
  std::string m_ID_reading_indication;
 
  std::vector<std::unique_ptr<KnowledgeElement>> m_KE_list; //Knowledge Element pool
  std::vector<std::unique_ptr<KnowledgeNode>> m_KN_list;
  std::vector<std::unique_ptr<KnowledgeUnit>> m_Knowledge_list;
  std::vector<std::unique_ptr<SentenceUnit>> m_Semantic_list;
 
 
  std::vector<std::unique_ptr<Statement>> m_Statement_list;
  std::vector<int> m_RM_Token_history;
  std::vector<float> m_RM_token_endtime_history;
  std::vector<std::unique_ptr<Investigator>> m_investigator_pool;
  std::vector<std::unique_ptr<InvestigatorLink>> m_investigator_link_pool;
 
  std::vector<Statement *> m_temporary_statement_list;
  std::vector<Statement *> m_new_Statement_list;
 
  std::vector<std::string> m_ID_temporary_statement_list;
  std::vector<std::string> m_ID_new_statement_list;
 
  std::vector<Investigator *> m_unresolved_investigator_pool;
  std::vector<Investigator *> m_resolved_investigator_pool;
  std::vector<Investigator *> m_success_investigator_pool; //3098, 3030
  std::vector<Investigator *> m_failed_investigator_pool; //
  std::vector<Investigator *> m_undetermined_investigator_pool; //3031
  std::vector<Investigator *> m_discarded_investigator_pool; //3090
  std::vector<Investigator *> m_cause_undetermined_investigato_pool; //3097
  std::vector<IDElement *> m_feedback_stack;
  std::vector<IDElement *> m_investigation_trace;
 
  std::vector<std::string> m_ID_unresolved_invest_pool;
  std::vector<std::string> m_ID_resolved_invest_pool;
  std::vector<std::string> m_ID_succes_invest_pool;
  std::vector<std::string> m_ID_failed_invest_pool;
  std::vector<std::string> m_ID_undertermined_invest_pool;
  std::vector<std::string> m_ID_discarded_invest_pool;
  std::vector<std::string> m_ID_cause_undertermined_invest_pool;
  std::vector<std::string> m_ID_feedback_stack;
  std::vector<std::string> m_ID_invest_trace;
 
  std::vector<MentalParameterValue *> m_tbi_P_list;
  std::vector<MentalAlarm *> m_tbi_A_list;
  std::vector<MentalComponentState *> m_tbi_C_list;
  std::vector<MentalSupportSystemState *> m_tbi_SS_list;
 
  std::vector<int> m_position_tbi_P_list;
  std::vector<int> m_position_tbi_A_list;
  std::vector<int> m_position_tbi_C_list;
  std::vector<int> m_position_tbi_SS_list;
 
  ReasonMachine();
  virtual ~ReasonMachine();
};