simulator.h

Go to the documentation of this file.

 
#ifndef SIMULATOR_H
#define SIMULATOR_H
 
namespace argos {
   class CSimulator;
   class CLoopFunctions;
   class CVisualization;
   class CPhysicsEngine;
   class CMedium;
   class CSpace;
   class CProfiler;
}
 
#include <argos3/core/config.h>
#include <argos3/core/utility/math/rng.h>
#include <argos3/core/utility/configuration/argos_configuration.h>
#include <argos3/core/utility/datatypes/datatypes.h>
#include <argos3/core/simulator/physics_engine/physics_engine.h>
#include <argos3/core/simulator/medium/medium.h>
#include <string>
#include <map>
 
namespace argos {
 
   class CSimulator {
 
   private:
 
      CSimulator();
 
      CSimulator(const CSimulator&) {}
 
      CSimulator& operator=(const CSimulator&) {
         return *this;
      }
 
   public:
 
      ~CSimulator();
 
      static CSimulator& GetInstance();
 
      inline CSpace& GetSpace() const {
         return *m_pcSpace;
      }
 
      CPhysicsEngine& GetPhysicsEngine(const std::string& str_id) const;
 
      inline CPhysicsEngine::TVector& GetPhysicsEngines() {
         return m_vecPhysicsEngines;
      }
 
      template <typename T>
      T& GetMedium(const std::string& str_id) {
         CMedium::TMap::const_iterator it = m_mapMedia.find(str_id);
         if(it != m_mapMedia.end()) {
            T* pcMedium = dynamic_cast<T*>(it->second);
            if(pcMedium != NULL) {
               return *pcMedium;
            }
            else {
               THROW_ARGOSEXCEPTION("Medium \"" << str_id << "\" can't be converted to the wanted type");
            }
         }
         else {
            THROW_ARGOSEXCEPTION("Medium \"" << str_id << "\" not found.");
         }
      }
 
      inline CMedium::TVector& GetMedia() {
         return m_vecMedia;
      }
 
      inline CVisualization& GetVisualization() {
         ARGOS_ASSERT(m_pcVisualization != NULL, "No visualization specified in the XML file.");
         return *m_pcVisualization;
      }
 
      inline TConfigurationNode& GetConfigurationRoot() {
         return m_tConfigurationRoot;
      }
 
      inline CProfiler& GetProfiler() {
         return *m_pcProfiler;
      }
 
      inline bool IsProfiling() const {
         return m_pcProfiler != NULL;
      }
 
      inline UInt32 GetRandomSeed() const {
         return m_unRandomSeed;
      }
 
      inline void SetRandomSeed(UInt32 un_random_seed) {
         m_unRandomSeed = un_random_seed;
         m_bWasRandomSeedSet = true;
      }
 
      inline CRandom::CRNG* GetRNG() {
         return m_pcRNG;
      }
 
      inline const std::string& GetExperimentFileName() const {
         return m_strExperimentConfigFileName;
      }
 
      inline void SetExperimentFileName(const std::string& str_file_name) {
         m_strExperimentConfigFileName = str_file_name;
      }
 
      inline CLoopFunctions& GetLoopFunctions() {
         return *m_pcLoopFunctions;
      }
 
      inline void SetLoopFunctions(CLoopFunctions& c_loop_functions) {
         m_pcLoopFunctions = &c_loop_functions;
      }
 
      inline UInt32 GetMaxSimulationClock() const {
         return m_unMaxSimulationClock;
      }
 
      inline UInt32 GetNumThreads() const {
         return m_unThreads;
      }
 
      inline bool IsRealTimeClock() const {
         return m_bRealTimeClock;
      }
 
      inline void SetRealTimeClock(bool b_real_time) {
         m_bRealTimeClock = b_real_time;
      }
 
      inline void Terminate() {
         m_bTerminated = true;
      }
 
      inline std::string GetInstallationDirectory() const {
         return ARGOS_INSTALL_PREFIX;
      }
 
      TConfigurationNode& GetConfigForController(const std::string& str_id);
 
      void Load(ticpp::Document& t_tree);
 
 
      void LoadExperiment();
 
      void Init();
 
      void Reset();
 
      inline void Reset(UInt32 un_new_random_seed) {
         SetRandomSeed(un_new_random_seed);
         Reset();
      }
 
      void Destroy();
 
      void Execute();
 
      void UpdateSpace();
 
      bool IsExperimentFinished() const;
 
   private:
 
      void InitFramework(TConfigurationNode& t_tree);
      void InitLoopFunctions(TConfigurationNode& t_tree);
      void InitControllers(TConfigurationNode& t_tree);
      void InitSpace(TConfigurationNode& t_tree);
      void InitPhysics(TConfigurationNode& t_tree);
      void InitPhysics2();
      void InitMedia(TConfigurationNode& t_tree);
      void InitMedia2();
      void InitVisualization(TConfigurationNode& t_tree);
 
   private:
 
      typedef std::map<std::string, TConfigurationNode*> TControllerConfigurationMap;
 
   private:
 
      TControllerConfigurationMap m_mapControllerConfig;
 
      CVisualization* m_pcVisualization;
 
      CPhysicsEngine::TMap m_mapPhysicsEngines;
 
      CPhysicsEngine::TVector m_vecPhysicsEngines;
 
      CMedium::TMap m_mapMedia;
 
      CMedium::TVector m_vecMedia;
 
      CSpace* m_pcSpace;
 
      CLoopFunctions* m_pcLoopFunctions;
 
      std::string m_strExperimentConfigFileName;
 
      UInt32 m_unMaxSimulationClock;
 
      UInt32 m_unRandomSeed;
 
      CRandom::CRNG* m_pcRNG;
 
      bool m_bWasRandomSeedSet;
 
      ticpp::Document m_tConfiguration;
 
      TConfigurationNode m_tConfigurationRoot;
 
      UInt32 m_unThreads;
 
      CProfiler* m_pcProfiler;
 
      bool m_bHumanReadableProfile;
 
      bool m_bRealTimeClock;
 
      bool m_bTerminated;
 
   };
 
}
 
#endif