SimScheduler.h

/******************************************************************************
* 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.
******************************************************************************/
/*
Scheduler header file
 
Author: Alex Reynolds
*/
#ifndef SIM_SCHEDULER_H
#define SIM_SCHEDULER_H
 
#include <vector>
 
#include "architecture/Scheduler.h"
#include "simulation/SimTimeManager.h"
#include "core/clockwerkerrors.h"
#include "models/support/SixDOFDynamicsModel.h"
#include "six_dof_dynamics/Frame.hpp"
#include "SimulationSteps.h"
 
namespace modelspace {
 
    /// @brief  Simple implementation of the scheduler class
 
    /// This class is a base implementation of scheduler. It is an empty
    /// base class and cannot be used without implementation in a derived
    /// child class.
 
    /// The scheduler is used to execute models, tasks, monitors, and events
    /// in a sequence and format as defined in the derived scheduler class.
 
    /// Note: This scheduler is intended for use explicitly in simulation
    /// with the 6-DOF dynamics model. It manually adds the 6-DOF dynamics
    /// and uses it internally for time and integrator calculations.
    class SimScheduler : public clockwerk::Scheduler {
    public:
        ///         Signal name             Type                        Default
        START_PARAMS
            /// The integrator type for the scheduler. Sets how models are integrated
            SIGNAL(integrator_type,         int,                        4)
            /// This is a pointer to the simulation's root frame. Sets frame for dynamics model
            SIGNAL(root_frame_ptr,          clockwerk::Frame<double>*,  nullptr)
            /// The maximum multiple of real time at which the sim will run on a single step.
            /// For example, 2 will make the simulation cap speed at double real time.
            /// Any negative number does not set a cap on run speed. This is the default behavior.
            /// This multiple is achieved by blocking on start step to ensure the timing multiple
            /// is met.
            SIGNAL(max_real_time_multiple,  int,                        -1)
        END_PARAMS
 
        START_INPUTS
            /// This is the rate at which the scheduler should run, as a Time object
            SIGNAL(rate,                clockwerk::Time,    clockwerk::Time(1,0))
        END_INPUTS
 
        START_OUTPUTS
            /// The time at which the last scheduler step was entered
            SIGNAL(entry_time,              clockwerk::Time,            clockwerk::Time())
            /// The time at which the last scheduler step was exited. Does not change wrt max_real_time_multiple.
            SIGNAL(exit_time,               clockwerk::Time,            clockwerk::Time())
        END_OUTPUTS
 
        /// @brief   Constructor for the scheduler.
        /// @note    Does note resolve all dependencies - executive needs to be set
        SimScheduler(clockwerk::Executive &executive);
 
        /// @brief   Function to start and configure the scheduler prior to run.
        /// @return  Error code corresponding to success/failure
        int startup();
 
        /// @brief   Function to step the scheduler by a single step
        /// @param   step_size The step size (as a time object) to step the sim by. Any nsec value greater
        ///          than NSEC_MAX will cause step to take the input step size, which is the default behavior.
        ///          Setting time to a valid time will step by that time rather than the input value.
        /// @return  Error code corresponding to success/failure
        /// @note    Overrides input step size parameter
        int step(const clockwerk::Time &step_size = clockwerk::Time(0, NSEC_MAX + 1));
 
        /// @brief   Function to run the scheduler until pre-determined end conditions
        ///          identified/calculated by the scheduler
        /// @return  Error code corresponding to success/failure
        /// @note    The scheduler MUST define stopping conditions. Otherwise, will run indefinitely
        int run();
 
        /// @brief   Function to register tasks with the scheduler. Depending
        ///          on the scheduler implementation these may be unused
        /// @param task The task to register
        /// @return Error code corresponding to success/failure
        virtual int registerTask(clockwerk::Task* task) override;
 
        /// @brief   Function to set the scheduler for termination
        void terminate() {_is_terminated = true;}
 
        /// @brief   Function to indicate whether the scheduler is terminated
        /// @return  The termination flag status
        virtual bool isTerminated() {return _is_terminated;}
 
        /// @brief Function to set the local model log level
        /// @param new_level The new level to set logging to
        void logLevel(clockwerk::log_level_e new_level) {_local_log_level = new_level;}
 
        /// Time manager to handle all time in the scheduler
        modelspace::SimTimeManager time;
    protected:
        /// @brief Function to execute a single task thread
        /// @param task_thread The task thread to execute
        /// @return Error code corresponding to success/failure
        int _executeTaskThread(std::vector<clockwerk::Task*> &task_thread);
 
        /// Vectors to store the sequences for each element of the simulation scheduler
        std::vector<clockwerk::Task*> _all_tasks;
        std::vector<clockwerk::Task*> _startup;
        std::vector<std::vector<clockwerk::Task*>> _start_step;
        std::vector<std::vector<clockwerk::Task*>> _derivative;
        std::vector<std::vector<clockwerk::Task*>> _end_step;
 
        /// Variable to terminate the simulation. The simulation run
        /// function terminates when this flag is set
        bool _is_terminated;
 
        /// Variable to catch errors from stuff
        int _error;
 
        /// Our 6-DOF dynamics model
        SixDOFDynamicsModel _dynamics;
 
        // Timing variables to ensure real time lock
        bool _is_first_step = true;
        clockwerk::Time _sim_time_step;
        clockwerk::Time _real_time_step;
        clockwerk::Time _next_time;
    };
}
 
#endif