Model.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.
******************************************************************************/
/*
Model header file - Includes declaration for model class which is the simulation base unit
 
Author: Alex Reynolds
*/
#ifndef SIMULATION_MODEL_H
#define SIMULATION_MODEL_H
 
#include "architecture/Tasks.h"
#include "simulation/SimulationExecutive.h"
#include "SimulationSteps.h"
 
namespace modelspace {
 
    ///  @brief   Base model class for derived implementation
    /// 
    ///  This is the base model class, which should be implemented in derived
    ///  models via class inheritence. It is designed around the "black box"
    ///  design of models, where each model is given startup parameters, inputs,
    ///  and outputs as defined:
    ///
    ///  PARAMETERS:     Configuration flags which should be carefully controlled
    ///                  and only modified at few, select events (i.e. not every
    ///                  timestep)
    ///  INPUTS:         Input parameters to the model which may, but do not have
    ///                  to, change often. These will often be connected to the
    ///                  outputs of other models.
    ///  OUTPUTS:        Output parameters from the model which are the result
    ///                  of an internal calculation in the model.
    ///
    ///  Functions are created in the base model class to be implemented in the
    ///  derived model. Each of the following may be left unmodified, in which case
    ///  they will do nothing. Functions should only be modified if the developer
    ///  wants them to do something. Once implemented, the functions will be called
    ///  automatically by the model and should not be invoked directly.
    ///
    ///  Functionally, Model is no different than Task. However, Models are configured
    ///  for simulation specifically to work with the SimulationExecutive. This makes
    ///  a number of model features easier to use at the expense of making them non-
    ///  embedded C++.
    class Model : public clockwerk::Task {
    public:
        /// @brief  Default constructor for the task object for simplicity.
        ///         Note: Masks some functionality and should not be used for
        ///         production deployment.
        Model();
 
        /// @brief Task-based constructor for the task. Auto-assigns executive
        /// @param pnt The task to assign as parent of this task
        /// @param nme Name of the task
        Model(Model &pnt, const std::string &m_name="Unnamed");
 
        /// @brief Executive-based constructor for the task
        /// @param executive The executive to set
        /// @param m_name The name for the task
        Model(SimulationExecutive &executive, const std::string &m_name="Unnamed");
 
        /// @brief Task-based constructor for the task. Auto-assigns executive
        /// @param pnt The task to assign as parent of this task
        /// @param nme Name of the task
        /// @param schedule_slot The slot to which the task should be scheduled. 
        ///                      Negative indicates it should not be scheduled. 
        ///                      Default is to schedule for ALL steps.  
        Model(Model &pnt, int schedule_slot, const std::string &m_name="Unnamed");
 
        /// @brief Executive-based constructor for the task
        /// @param executive The executive to set
        /// @param m_name The name for the task
        /// @param schedule_slot The slot to which the task should be scheduled. 
        ///                      Negative indicates it should not be scheduled.    
        ///                      Default is to schedule for ALL steps.  
        Model(SimulationExecutive &executive, int schedule_slot, const std::string &m_name="Unnamed");
 
        /// @brief Desrtuctor. Doesn't really do anything
        virtual ~Model() {};
 
    protected:
        /// Override our executive to include the SimulationExecutive instead. 
        /// Models will work with the SimulationExecutive per Alex decision 5/2024.
        /// In all other respects they will be identical to tasks.
        SimulationExecutive* exc = nullptr;
    };
 
}
 
#endif