SimulationExecutive.h

Go to the documentation of this file.

/******************************************************************************
* Copyright (c) ATTX INC 2025. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX INC. 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 INC.
******************************************************************************/
/*
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 "SimLinux.h"
#include "SimPlatform.h"
#include "SimSetup.h"
#include "flight/Scheduler.h"
 
namespace warptwin {
    class TimeTriggerMonitor;
    class SimTerminationEvent;

    class SimulationExecutive : public warpos::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);

        warptwin::LogManager& logManager() {return _log_manager;}

        warptwin::SimScheduler& schedule() {return _sim_scheduler;}

        warptwin::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;}

        warptwin::ArgParser& args() {return _args;}

        warptwin::DispersionEngine& dispersions() {return _dispersion_engine;}

        warptwin::SimTimeManager& time() {return _sim_scheduler.time;}

        double simTime() {return time().base_time().asFloatingPoint();}

        warptwin::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 terminate() {_scheduler.terminate();}

        void writeSimDataToJson(const std::string &filename);

        int registerApp(warpos::App& app, int16 slot) {return _sim_scheduler.registerApp(app, slot);}

        int scheduleTelemetry(int apid, clockwerk::Time rate);

        void setWarpLinkInterface(std::string ip="127.0.0.1", uint32 tlm_port=5005, uint32 cmd_port=5006) 
            {_sim_setup.setWarpLinkInterface(ip, tlm_port, cmd_port);}

        void connectExternalSocket(clockwerk::DataIOBase& signal, std::string mode, 
                                   const std::string &ip, int port) 
            {_sim_scheduler.connectExternalSocket(signal, mode, ip, port);}

        void connectExternalSharedMemory(clockwerk::DataIOBase& signal, std::string mode,
                                         const std::string shmem_address)
            {_sim_scheduler.connectExternalSharedMemory(signal, mode, shmem_address);}
    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;

        bool _real_time_mode = false;

        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
        SimLinux _sim_os;
        SimPlatform _sim_platform;
        SimSetup _sim_setup;
 
        // Internal reference to simulation executive itself for logging
        SimulationExecutive& exc;
    };
 
}
 
#endif