simulation.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// Copyright (C) 2021 CERN & University of Surrey for the benefit of the
// BioDynaMo collaboration. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//
// See the LICENSE file distributed with this work for details.
// See the NOTICE file distributed with this work for additional information
// regarding copyright ownership.
//
// -----------------------------------------------------------------------------
#ifndef CORE_SIMULATION_H_
#define CORE_SIMULATION_H_
 
#include <functional>
#include <string>
#include <vector>
 
#include "core/agent/agent_uid.h"
#include "core/gpu/opencl_state.h"
#include "core/memory/memory_manager.h"
#include "core/util/random.h"
#include "core/util/root.h"
 
namespace bdm {
 
// forward declarations
class ResourceManager;
class Environment;
class Grid;
class Scheduler;
struct Param;
class ExecutionContext;
class CommandLineOptions;
class AgentUidGenerator;
 
class SimulationTest;
class ParaviewAdaptorTest;
 
namespace experimental {
class TimeSeries;
}  // namespace experimental
 
class Simulation {
 public:
  static Simulation* GetActive();
 
  explicit Simulation(TRootIOCtor* p);
  Simulation(int argc, const char** argv,
             const std::vector<std::string>& config_files = {});
 
  explicit Simulation(CommandLineOptions* clo,
                      const std::vector<std::string>& config_files = {});
 
  explicit Simulation(const std::string& simulation_name,
                      const std::vector<std::string>& config_files = {});
 
  Simulation(int argc, const char** argv,
             const std::function<void(Param*)>& set_param,
             const std::vector<std::string>& config_files = {});
 
  Simulation(CommandLineOptions* clo,
             const std::function<void(Param*)>& set_param,
             const std::vector<std::string>& config_files = {});
 
  Simulation(const std::string& simulation_name,
             const std::function<void(Param*)>& set_param,
             const std::vector<std::string>& config_files = {});
 
  ~Simulation();
 
  void Restore(Simulation&& restored);
 
  void Activate();
 
  ResourceManager* GetResourceManager();
 
  void SetResourceManager(ResourceManager* rm);
 
  const Param* GetParam() const;
 
  AgentUidGenerator* GetAgentUidGenerator();
 
  Environment* GetEnvironment();
 
  void SetEnvironment(Environment* env);
 
  Scheduler* GetScheduler();
 
  void Simulate(uint64_t steps);
 
  Random* GetRandom();
 
  std::vector<Random*>& GetAllRandom();
 
  ExecutionContext* GetExecutionContext();
 
  std::vector<ExecutionContext*>& GetAllExecCtxts();
 
  void SetAllExecCtxts(const std::vector<ExecutionContext*>& exec_ctxts);
 
  MemoryManager* GetMemoryManager() { return mem_mgr_; }
 
  OpenCLState* GetOpenCLState();
 
  const std::string& GetUniqueName() const;
 
  const std::string& GetOutputDir() const;
 
  experimental::TimeSeries* GetTimeSeries();
 
  void ReplaceScheduler(Scheduler* scheduler);
 
 private:
  static Simulation* active_;
  static std::atomic<uint64_t> counter_;
 
  std::vector<Random*> random_;
 
  std::vector<ExecutionContext*> exec_ctxt_;  
 
  ResourceManager* rm_ = nullptr;
  Param* param_ = nullptr;
  AgentUidGenerator* agent_uid_generator_ = nullptr;  
  std::string name_;
  Environment* environment_ = nullptr;  
  Scheduler* scheduler_ = nullptr;      
  OpenCLState* ocl_state_ = nullptr;    
  bool is_gpu_environment_initialized_ = false;
  uint64_t id_ = 0;  
  std::string unique_name_;  
  std::string output_dir_;  
  std::string command_line_parameter_str_;  
  MemoryManager* mem_mgr_ = nullptr;  
  int64_t ctor_ts_ = 0;  
  int64_t dtor_ts_ = 0;  
  experimental::TimeSeries* time_series_ = nullptr;
 
  void Initialize(CommandLineOptions* clo,
                  const std::function<void(Param*)>& set_param,
                  const std::vector<std::string>& config_files);
 
  void InitializeMembers();
 
  void InitializeRuntimeParams(CommandLineOptions* clo,
                               const std::function<void(Param*)>& set_param,
                               const std::vector<std::string>& ctor_config);
 
  void LoadConfigFiles(const std::vector<std::string>& ctor_configs,
                       const std::vector<std::string>& cli_configs);
 
  void InitializeUniqueName(const std::string& simulation_name);
 
  void InitializeOutputDir();
 
  friend SimulationTest;
  friend ParaviewAdaptorTest;
  friend class DiffusionTest_CopyOldData_Test;
  friend std::ostream& operator<<(std::ostream& os, Simulation& sim);
 
  BDM_CLASS_DEF_NV(Simulation, 1);
};
 
}  // namespace bdm
 
#endif  // CORE_SIMULATION_H_