SimulationExecutive.h

Go to the documentation of this file.

/******************************************************************************
* Copyright (c) ATTX LLC 2024. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX, LLC. The Software is 
* furnished under a license agreement between ATTX and the user organization 
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION 
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or 
* transmitted in any form or by any means, for any purpose, without the express 
* written permission of ATTX, LLC.
******************************************************************************/
/*
Simulation Executive header file
 
Author: Alex Reynolds
*/
#ifndef SIMULATION_SIMULATION_EXECUTIVE_H
#define SIMULATION_SIMULATION_EXECUTIVE_H
 
#include "flight/FlightExecutive.h"
#include "frames/Frame.h"
#include "core/clockwerkerrors.h"
#include "simulation/SimScheduler.h"
#include "simulation/ArgParser.h"
#include "simulation/DispersionEngine.h"
#include "simulation/SimTimeManager.h"
#include "logging/LogManager.h"
#include "logging/CsvLogger.h"
#include "simulation/VisualsModel.h" 
#include "utils/spiceutils.h"
#include "Linux.h"
#include "SimPlatform.h"
 
namespace modelspace {
    class TimeTriggerMonitor;
    class SimTerminationEvent;
 
    class SimulationExecutive : public cfspp::FlightExecutive {
    public:
        SimulationExecutive();
        ~SimulationExecutive();
 
        int parseArgs(int argc, char *argv[]);
 
        int parseArgs(std::vector<std::string> arguments);
 
        void integrator(int val) {_sim_scheduler.params.integrator_type(val);}
        int integrator() {return _sim_scheduler.params.integrator_type();}
 
        void setRateHz(unsigned int rate_hz);
 
        void setRateSec(clockwerk::Time rate_sec);
        void setRateSec(struct timespec rate_sec);
        void setRateSec(double rate_sec);
 
        void end(clockwerk::Time end_time);
        void end(struct timespec end_time);
        void end(double end_time);
 
        clockwerk::Time end();
 
        int16 startup();
 
        int16 step();
 
        int16 step(const clockwerk::Time &step_size);
 
        int16 run();
 
        clockwerk::Time rate() {return _sim_scheduler.inputs.rate();}
 
        Frame& rootFrame() {return _root_frame;}
 
        std::vector<std::string> search(const std::string &s_val);
 
        std::vector<std::string> searchFrameTree(const std::string &s_val);
 
        std::vector<std::string> searchSimTree(const std::string &s_val);
 
        modelspace::LogManager& logManager() {return _log_manager;}
 
        modelspace::SimScheduler& schedule() {return _sim_scheduler;}
 
        modelspace::VisualsModel& visualsModel() {return *_visuals_model;}
 
        void enableVisuals();
 
        void disableVisuals();
 
        bool visualsEnabled() {return _visuals_model != nullptr;}
 
        unsigned int runNumber() {return _run_num;}
 
        void runNumber(unsigned int run_num) {_run_num = run_num;}
 
        modelspace::ArgParser& args() {return _args;}
 
        modelspace::DispersionEngine& dispersions() {return _dispersion_engine;}
 
        modelspace::SimTimeManager& time() {return _sim_scheduler.time;}
 
        double simTime() {return time().base_time().asFloatingPoint();}
 
        modelspace::SpiceManager& spiceManager() {return _spice_manager;}
 
        void setTime(const std::string &time_in) {time().setTime(time_in);}
 
        bool started() {return _started;}
 
        bool isTerminated() {return _scheduler.isTerminated();}
 
        void writeSimDataToJson(const std::string &filename);
 
        int registerApp(cfspp::App& app, int16 slot) {return _sim_scheduler.registerApp(app, slot);}
 
    protected:
        void _configLogEverything(const std::string &filename);
 
        void _configureFromCmdLine();
 
        void _printSimInfo();
 
        ArgParser _args;
        
        DispersionEngine _dispersion_engine;
        int _rng_seed = 0;
 
        unsigned int _run_num = 0;
 
        Frame _root_frame;
 
        LogManager _log_manager;
        SimScheduler _sim_scheduler;
 
        SpiceManager _spice_manager;
 
        // NOTE: We have to allocate on the heap here due to the fact that these are
        // now models.
        TimeTriggerMonitor* _term_monitor;
        SimTerminationEvent* _term_event;
 
        VisualsModel* _visuals_model = nullptr;
 
        log_level_e _local_log_level = LOG_INFO;
 
        bool _started = false;
 
        unsigned long long _step_count = 0;
 
        CsvLogger* _all_log = nullptr;
 
        // Placeholder variables for OS, Platform, Setup, which are required by flight executive
        // but not currently used in sim executive
        Linux _null_os;
        SimPlatform _null_platform;
        cfspp::Setup _null_setup;
 
        // Internal reference to simulation executive itself for logging
        SimulationExecutive& exc;
    };
 
}
 
#endif