.. _program_listing_file_agents_agent.h:

Program Listing for File agent.h
================================

|exhale_lsh| :ref:`Return to documentation for file <file_agents_agent.h>` (``agents/agent.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   
   #pragma once
   
   #include <memory>
   
   #include "lupnt/core/asset_factory.h"
   #include "lupnt/core/config.h"
   #include "lupnt/core/constants.h"
   #include "lupnt/core/data_logger.h"
   #include "lupnt/core/object.h"
   #include "lupnt/dynamics/attitude_dynamics.h"
   #include "lupnt/dynamics/dynamics.h"
   #include "lupnt/states/state.h"
   
   namespace lupnt {
   
     class Simulation;
     class Channel;
     class Application;
     class Device;
     class Agent;
   
     using DeviceFactory = AssetFactory<Device, YAML::Node&>;
     using AgentFactory = AssetFactory<Agent, YAML::Node&>;
     using ApplicationFactory = AssetFactory<Application, YAML::Node&>;
     using DynamicsFactory = AssetFactory<Dynamics, YAML::Node&>;
     using ChannelFactory = AssetFactory<Channel, YAML::Node&>;
   
     class Agent : public Object<Agent>, public DataLogger {
     protected:
       // Config
       std::string name_;
       Simulation* sim_ = nullptr;
       Config config_;
       Real frequency_ = 0.0;
       Real time_ = 0.0;
       State state_ = State();
   
       // Devices
       std::map<std::string, Ptr<Device>> devices_;
   
       // Application
       Ptr<Application> application_;
   
     public:
       Agent() = default;
   
       Agent(Config& agent_config);
   
       Simulation* GetSimulation() const {
         LUPNT_CHECK(sim_, "Simulation not set", "Agent");
         return sim_;
       }
       void SetSimulation(Simulation* sim) { sim_ = sim; }
   
       Real GetTime() const { return time_; }
       void SetTime(Real t) { time_ = t; }
   
       std::string GetName() const { return name_; }
       void SetName(std::string name) { name_ = name; }
   
       std::map<std::string, Ptr<Device>> GetDevices() const { return devices_; }
   
       void AddDevice(Ptr<Device> device);
   
       Ptr<Device> GetDevice(const std::string& name) const;
   
       Ptr<Application> GetApplication() const { return application_; }
       void SetApplication(Ptr<Application> app) { application_ = app; }
   
       virtual void Setup();
   
       virtual void Step(Real time);
   
       State GetState() const { return State(); }
       void SetState(const State& state) { state_ = state; }
   
       virtual Cart6 GetStateAt(Real t) const = 0;
   
       virtual void Log(Real time);
   
       virtual void LogCesium();
     };
   
     class AgentWithDynamics : public Agent {
     protected:
       // Config
       BodyId body_id_;
       Real precompute_ = 0.0;  // [s]
       Real frequency_ = 0.0;   // [Hz]
   
       // State
       Real time_ = 0.0;  // [s]
       Cart6 state_;
       Attitude attitude_;
       State control_;
   
       // Dynamics
       Ptr<Dynamics> dynamics_;
       Ptr<AttitudeDynamics> attitude_dynamics_;
   
     public:
       AgentWithDynamics() = default;
   
       AgentWithDynamics(Config& agent_config);
   
       virtual void Setup() override;
   
       virtual void Step(Real time) override;
   
       Real GetTime() const { return time_; }
       void SetTime(Real t) { time_ = t; }
   
       Real GetFrequency() const { return frequency_; }
       void SetFrequency(Real frequency) { frequency_ = frequency; }
   
       State GetState() const { return state_; }
       void SetState(const State& x) { state_ = x; }
   
       Attitude GetAttitude() const { return attitude_; }
       void SetAttitude(const Attitude& attitude) { attitude_ = attitude; }
   
       State GetControl() const { return control_; }
       void SetControl(const State& control) { control_ = control; }
   
       Dynamics* GetDynamics() const {
         LUPNT_CHECK(dynamics_, "Dynamics not set", "Agent");
         return dynamics_.get();
       }
       void SetDynamics(Ptr<Dynamics> dyn) { dynamics_ = std::move(dyn); }
   
       AttitudeDynamics* GetAttitudeDynamics() const {
         LUPNT_CHECK(attitude_dynamics_, "Attitude dynamics not set", "Agent");
         return attitude_dynamics_.get();
       }
       void SetAttitudeDynamics(Ptr<AttitudeDynamics> dyn) { attitude_dynamics_ = std::move(dyn); }
   
       void SetBodyId(BodyId body_id) { body_id_ = body_id; }
       BodyId GetBodyId() const { return body_id_; }
   
       virtual void Propagate(Real t);
   
       virtual Cart6 GetStateAt(Real t) const override;
   
       virtual Attitude GetAttitudeAt(Real t) const;
   
       // Log
   
       virtual void Log(Real time) override;
   
       virtual void LogCesium() override;
     };
   
   };  // namespace lupnt