macros.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.
******************************************************************************/
/*
Macros Header File
------------------
This file contains macro definitions to invoke specialized
versions of templated classes. The classes defined here
are guaranteed to be available to SWIG implementations
as well.
 
Author: Alex Reynolds
*/
#ifndef CLOCKWERK_MACROS_H
#define CLOCKWERK_MACROS_H
 
// --------------------------------------------------------------------------
// Matrix definitions for easy use in C++ and SWIG Implementations
// --------------------------------------------------------------------------
#define Matrix2D clockwerk::Matrix<double, 2, 2>
#define Matrix3D clockwerk::Matrix<double, 3, 3>
#define Matrix3F clockwerk::Matrix<float, 3, 3>
#define Matrix4D clockwerk::Matrix<double, 4, 4>
#define Matrix4F clockwerk::Matrix<float, 4, 4>
#define Matrix6D clockwerk::Matrix<double, 6, 6>
#define Matrix6F clockwerk::Matrix<float, 6, 6>
#define Matrix21D clockwerk::Matrix<double, 2, 1>
#define Matrix31D clockwerk::Matrix<double, 3, 1>
#define Matrix31F clockwerk::Matrix<float, 3, 1>
#define Matrix41D clockwerk::Matrix<double, 4, 1>
#define Matrix41F clockwerk::Matrix<float, 4, 1>
#define Matrix61D clockwerk::Matrix<double, 6, 1>
#define Matrix61F clockwerk::Matrix<float, 6, 1>
#define Matrix63D clockwerk::Matrix<double, 6, 3>
#define Matrix63F clockwerk::Matrix<float, 6, 3>
 
// --------------------------------------------------------------------------
// Vector definitions for easy use in C++ and SWIG Implementations
// --------------------------------------------------------------------------
#define CartesianVector2D clockwerk::CartesianVector<double, 2>
#define CartesianVector2F clockwerk::CartesianVector<float, 2>
#define CartesianVector3D clockwerk::CartesianVector<double, 3>
#define CartesianVector3F clockwerk::CartesianVector<float, 3>
#define CartesianVector4D clockwerk::CartesianVector<double, 4>
#define CartesianVector4F clockwerk::CartesianVector<float, 4>
#define CartesianVector6D clockwerk::CartesianVector<double, 6>
#define CartesianVector6F clockwerk::CartesianVector<float, 6>
 
// --------------------------------------------------------------------------
// Frame/6-DOF definitions for easy use in C++ and SWIG Implementations
// --------------------------------------------------------------------------
#define FrameD clockwerk::Frame<double>
#define FrameF clockwerk::Frame<float>
#define BodyD clockwerk::Body<double>
#define BodyF clockwerk::Body<float>
#define NodeD clockwerk::Node<double>
#define NodeF clockwerk::Node<float>
#define DCMD clockwerk::DCM<double>
#define DCMF clockwerk::DCM<float>
#define Euler321D clockwerk::Euler321<double>
#define Euler321F clockwerk::Euler321<float>
#define JointD clockwerk::Joint<double>
#define JointF clockwerk::Joint<float>
#define MRPD clockwerk::MRP<double>
#define MRPF clockwerk::MRP<float>
#define QuaternionD clockwerk::Quaternion<double>
#define QuaternionF clockwerk::Quaternion<float>
 
// --------------------------------------------------------------------------
// Model, Task, Monitor, Event definitions for easy use in C++ and SWIG 
// Implementations
// --------------------------------------------------------------------------
#define REQUIRED(NAME, TYPE) clockwerk::DataIO<TYPE> NAME = clockwerk::DataIO<TYPE>(this, #NAME);
#define OPTIONAL(NAME, TYPE, DEFAULT_VALUE) clockwerk::DataIO<TYPE> NAME = clockwerk::DataIO<TYPE>(this, #NAME, DEFAULT_VALUE);
#define SIGNAL(NAME, TYPE, INITIAL_VALUE) clockwerk::DataIO<TYPE> NAME = clockwerk::DataIO<TYPE>(this, #NAME, INITIAL_VALUE);
#define START_OUTPUTS struct Outputs : clockwerk::GraphTreeObject {
        Outputs(clockwerk::GraphTreeObject* par, std::string nme) {_name=nme; parent(par);}
#define END_OUTPUTS };
    Outputs outputs = Outputs(this, "outputs");
#define START_INPUTS struct Inputs : clockwerk::GraphTreeObject {
        Inputs(clockwerk::GraphTreeObject* par, std::string nme) {_name=nme; parent(par);}
#define END_INPUTS };
    Inputs inputs = Inputs(this, "inputs");
#define START_PARAMS struct Params : clockwerk::GraphTreeObject {
        Params(clockwerk::GraphTreeObject* par, std::string nme) {_name=nme; parent(par);}
#define END_PARAMS };
    Params params = Params(this, "params");
 
// --------------------------------------------------------------------------
// Logging macro to make event logging easy
// --------------------------------------------------------------------------
// This macro works only inside models, tasks, monitors, and events -- it receives
// the log message and associated log level as arguments, and implicitly receives 
// the local and gloabl log levels via the executive and known variables in those items  
// If the log level is error, prints the file/function/line where the error is logged
#define LOG(LEVEL, MESSAGE)
    if(exc != nullptr) {
        if(LEVEL <= exc->eventLog()->logLevel() || LEVEL <= _local_log_level) {
            exc->eventLog()->logMessage(LEVEL, address() + ":\t" + MESSAGE, _local_log_level);
            if(LEVEL == ERROR) {
                exc->eventLog()->logMessage(LEVEL, "FILE : " + std::string(__FILE__));
                exc->eventLog()->logMessage(LEVEL, "FUNCTION : " + std::string(__func__));
                exc->eventLog()->logMessage(LEVEL, "LINE : " + std::to_string(__LINE__));
            }
        }
    }
 
// Header for our clockwerk page
/*! \mainpage Clockwerk Doxygen Landing Page
 *
 * \section intro_sec Overview
 *
 * This module contains all C++ documentation generated for 
 * the Clockwerk module. Clockwerk includes all base tools and
 * utilities necessary to build a software instance. That includes
 * matrix math, dynamics, attitude representations, software 
 * architecture, logging, and other general utilities. See the
 * class list for more information.
 */
 
#endif