agent.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_AGENT_AGENT_H_
#define CORE_AGENT_AGENT_H_
 
#include <algorithm>
#include <cassert>
#include <limits>
#include <memory>
#include <set>
#include <sstream>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <vector>
 
#include "core/agent/agent_pointer.h"
#include "core/agent/agent_uid.h"
#include "core/agent/new_agent_event.h"
#include "core/container/inline_vector.h"
#include "core/container/math_array.h"
#include "core/interaction_force.h"
#include "core/shape.h"
#include "core/util/macros.h"
#include "core/util/root.h"
#include "core/util/spinlock.h"
#include "core/util/type.h"
 
namespace bdm {
 
#define BDM_AGENT_HEADER(class_name, base_class, class_version_id)           \
 public:                                                                     \
  using Base = base_class;                                                   \
                                                                             \
  explicit class_name(TRootIOCtor* io_ctor) {}                               \
                                                                             \
 \
  Agent* New() const override { return new class_name(); }                   \
    \
  Agent* NewCopy() const override { return new class_name(*this); }          \
                                                                             \
  const char* GetTypeName() const override { return #class_name; }           \
                                                                             \
 protected:                                                                  \
                \
  Base* UpCast() { return static_cast<Base*>(this); }                        \
                                                                             \
                \
  const Base* UpCast() const { return static_cast<const Base*>(this); }      \
                                                                             \
  BDM_CLASS_DEF_OVERRIDE(class_name, class_version_id)
 
// -----------------------------------------------------------------------------
 
class Behavior;
 
class Agent {
 public:
  Agent();
 
  explicit Agent(TRootIOCtor* io_ctor);
 
  Agent(const Agent& other);
 
  virtual ~Agent();
 
  virtual Agent* New() const = 0;
 
  virtual Agent* NewCopy() const = 0;
 
  virtual void Initialize(const NewAgentEvent& event);
 
  virtual void Update(const NewAgentEvent& event);
 
  void CreateNewAgents(const NewAgentEvent& event,
                       const std::initializer_list<Agent*>& prototypes) {
    auto* ctxt = Simulation::GetActive()->GetExecutionContext();
    event.existing_agent = this;
    for (auto* p : prototypes) {
      auto* new_agent = p->New();
      new_agent->Initialize(event);
      event.new_agents.push_back(new_agent);
      ctxt->AddAgent(new_agent);
    }
    Update(event);
  }
 
  virtual const char* GetTypeName() const { return "Agent"; }
 
  virtual Shape GetShape() const = 0;
 
  virtual std::set<std::string> GetRequiredVisDataMembers() const {
    return {"position_", "diameter_"};
  }
 
  virtual void RunDiscretization();
 
  void AssignNewUid();
 
  const AgentUid& GetUid() const;
 
  Spinlock* GetLock() { return &lock_; }
 
  virtual void CriticalRegion(std::vector<AgentPointer<>>* aptrs) {}
 
  uint32_t GetBoxIdx() const;
 
  void SetBoxIdx(uint32_t idx);
 
  void SetStaticnessNextTimestep(bool value) const {
    is_static_next_ts_ = value;
  }
 
  bool GetPropagateStaticness() const {
    return propagate_staticness_neighborhood_;
  }
 
  void SetPropagateStaticness(bool value = true) {
    propagate_staticness_neighborhood_ = value;
  }
 
  void PropagateStaticness(bool beginning = false);
 
  void UpdateStaticness();
 
  bool IsStatic() const { return is_static_; }
 
  template <typename TAgent = Agent>
  AgentPointer<TAgent> GetAgentPtr() const {
    static_assert(!std::is_pointer<TAgent>::value,
                  "Cannot be of pointer type!");
    if (gAgentPointerMode == AgentPointerMode::kIndirect) {
      return AgentPointer<TAgent>(uid_);
    } else {
      return AgentPointer<TAgent>(
          const_cast<TAgent*>(Cast<const Agent, const TAgent>(this)));
    }
  }
 
  // ---------------------------------------------------------------------------
  // Behaviors
  void AddBehavior(Behavior* behavior);
 
  void RemoveBehavior(const Behavior* behavior);
 
  void RunBehaviors();
 
  const InlineVector<Behavior*, 2>& GetAllBehaviors() const;
  // ---------------------------------------------------------------------------
 
  virtual Real3 CalculateDisplacement(const InteractionForce* force,
                                      real_t squared_radius, real_t dt) = 0;
 
  virtual void ApplyDisplacement(const Real3& displacement) = 0;
 
  virtual const Real3& GetPosition() const = 0;
 
  virtual void SetPosition(const Real3& pos) = 0;
 
  virtual real_t GetDiameter() const = 0;
 
  virtual void SetDiameter(real_t diameter) = 0;
 
  virtual void RemoveFromSimulation();
 
  void* operator new(size_t size) {  // NOLINT
    auto* mem_mgr = Simulation::GetActive()->GetMemoryManager();
    if (mem_mgr) {
      return mem_mgr->New(size);
    } else {
      return malloc(size);
    }
  }
 
  void operator delete(void* p) {  // NOLINT
    auto* mem_mgr = Simulation::GetActive()->GetMemoryManager();
    if (mem_mgr) {
      mem_mgr->Delete(p);
    } else {
      free(p);
    }
  }
 
 protected:
  AgentUid uid_;
  uint32_t box_idx_ = std::numeric_limits<uint32_t>::max();
  InlineVector<Behavior*, 2> behaviors_;
 
  template <typename TFrom, typename TTo>
  typename std::enable_if<std::is_base_of<TFrom, TTo>::value, TTo*>::type Cast(
      TFrom* agent) const {
    return static_cast<TTo*>(agent);
  }
 
  template <typename TFrom, typename TTo>
  typename std::enable_if<!std::is_base_of<TFrom, TTo>::value, TTo*>::type Cast(
      TFrom* agent) const {
    return dynamic_cast<TTo*>(agent);
  }
 
 private:
  Spinlock lock_;  
 
  uint16_t run_behavior_loop_idx_ = 0;
 
  bool is_static_ = false;  
  bool propagate_staticness_neighborhood_ = true;  
  mutable bool is_static_next_ts_ = false;  
 
  void InitializeBehaviors(const NewAgentEvent& event);
 
  void UpdateBehaviors(const NewAgentEvent& event);
 
  BDM_CLASS_DEF(Agent, 1)
};
 
}  // namespace bdm
 
#endif  // CORE_AGENT_AGENT_H_