param.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_PARAM_PARAM_H_
#define CORE_PARAM_PARAM_H_
 
#include <cinttypes>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#include "core/analysis/style.h"
#include "core/param/param_group.h"
#include "core/real_t.h"
#include "core/util/root.h"
#include "core/util/type.h"
 
namespace bdm {
 
class Simulation;
 
struct Param {
  static void RegisterParamGroup(ParamGroup* param);
 
  Param();
 
  ~Param();
 
  Param(const Param& other);
 
  void Restore(Param&& other);
 
  std::string ToJsonString() const;
 
  void MergeJsonPatch(const std::string& patch);
 
  template <typename TParamGroup>
  const TParamGroup* Get() const {
    if (groups_.find(TParamGroup::kUid) != groups_.end()) {
      return bdm_static_cast<const TParamGroup*>(groups_.at(TParamGroup::kUid));
    } else {
      Log::Error("TParamGroup::Get",
                 "Couldn't find the requested group parameter.");
      return nullptr;
    }
  }
 
  template <typename TParamGroup>
  TParamGroup* Get() {
    if (groups_.find(TParamGroup::kUid) != groups_.end()) {
      return bdm_static_cast<TParamGroup*>(groups_.at(TParamGroup::kUid));
    } else {
      Log::Error("TParamGroup::Get",
                 "Couldn't find the requested group parameter.");
      return nullptr;
    }
  }
 
  // simulation values ---------------------------------------------------------
  uint64_t random_seed = 4357;
 
  std::vector<std::string> unschedule_default_operations;
 
  enum NumericalODESolver { kEuler = 1, kRK4 = 2 };
  NumericalODESolver numerical_ode_solver = NumericalODESolver::kEuler;
 
  std::string output_dir = "output";
 
  std::string environment = "uniform_grid";
 
  uint32_t nanoflann_depth = 10;
 
  uint32_t unibn_bucketsize = 16;
 
  bool remove_output_dir_contents = true;
 
  std::string backup_file = "";
 
  std::string restore_file = "";
 
  uint32_t backup_interval = 1800;
 
  real_t simulation_time_step = 0.01;
 
  real_t simulation_max_displacement = 3.0;
 
  enum BoundSpaceMode {
    kOpen = 0,
    kClosed,
    kTorus
  };
 
  BoundSpaceMode bound_space = kOpen;
 
  real_t min_bound = 0;
 
  real_t max_bound = 100;
 
  std::string diffusion_boundary_condition = "Neumann";
 
 
  std::string diffusion_method = "euler";
 
  bool calculate_gradients = true;
 
  enum ThreadSafetyMechanism { kNone = 0, kUserSpecified, kAutomatic };
 
  ThreadSafetyMechanism thread_safety_mechanism =
      ThreadSafetyMechanism::kUserSpecified;
 
  // visualization values ------------------------------------------------------
 
  std::string visualization_engine = "paraview";
 
  bool insitu_visualization = false;
 
  bool export_visualization = false;
 
  bool root_visualization = false;
 
  std::string pv_insitu_pipeline =
      Concat(std::getenv("BDMSYS"),
             "/include/core/visualization/paraview/default_insitu_pipeline.py");
 
  std::string pv_insitu_pipelinearguments = "";
 
  uint32_t visualization_interval = 1;
 
  bool visualization_export_generate_pvsm = true;
 
  std::map<std::string, std::set<std::string>>
      visualize_agents;  
 
  struct VisualizeDiffusion {
    std::string name;
    bool concentration = true;
    bool gradient = false;
  };
 
  std::vector<VisualizeDiffusion> visualize_diffusion;
 
  bool visualization_compress_pv_files = true;
 
  // performance values --------------------------------------------------------
 
  uint64_t scheduling_batch_size = 1000;
 
  enum ExecutionOrder { kForEachAgentForEachOp = 0, kForEachOpForEachAgent };
 
  ExecutionOrder execution_order = ExecutionOrder::kForEachAgentForEachOp;
 
  bool detect_static_agents = false;
 
  bool cache_neighbors = false;
 
  bool use_bdm_mem_mgr = true;
 
  uint64_t mem_mgr_aligned_pages_shift = 5;
 
  real_t mem_mgr_growth_rate = 1.1;
 
  uint64_t mem_mgr_max_mem_per_thread_factor = 1;
 
  bool minimize_memory_while_rebalancing = true;
 
  enum MappedDataArrayMode { kZeroCopy = 0, kCopy, kCache };
 
  Param::MappedDataArrayMode mapped_data_array_mode =
      MappedDataArrayMode::kZeroCopy;
 
  // development values --------------------------------------------------------
  bool statistics = false;
 
#ifdef USE_LIBGIT2
  bool track_git_changes = true;
#endif  // USE_LIBGIT2
 
  bool debug_numa = false;
 
  uint64_t show_simulation_step = 0;
 
  bool use_progress_bar = false;
 
  std::string progress_bar_time_unit = "s";
 
  // ---------------------------------------------------------------------------
  // experimental group
 
  std::string compute_target = "cpu";
 
  bool opencl_debug = false;
 
  int preferred_gpu = -1;
 
  bool plot_memory_layout = false;
 
  void AssignFromConfig(const std::shared_ptr<cpptoml::table>&);
 
 private:
  friend class DiffusionTest_CopyOldData_Test;
  static std::unordered_map<ParamGroupUid, std::unique_ptr<ParamGroup>>
      registered_groups_;
  std::unordered_map<ParamGroupUid, ParamGroup*> groups_;
  BDM_CLASS_DEF_NV(Param, 1);
};
 
}  // namespace bdm
 
#endif  // CORE_PARAM_PARAM_H_