Spacecraft.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.
******************************************************************************/
/*
Spacecraft model header file
 
Author: Alex Reynolds
*/
/*
Metadata for MS GUI:
imdata = {"displayname" : "Spacecraft",
          "exclude" : False,
          "category" : "Assemblies"
}
aliases = {"initial_position" : "Initial Position",
           "initial_velocity" : "Initial Velocity",
           "pos_vel_init_frame" : "EXCLUDE",
           "initial_attitude" : "Initial Attitude",
           "initial_ang_vel" : "Initial Ang. Vel.",
           "att_init_frame" : "EXCLUDE",
           "planet_configuration" : "Planet Information",
           "planet_inertial_frame" : "Planet Inertial Frame",
           "planet_rotating_frame" : "Planet Rotating Frame",
           "body" : "Spacecraft Body",
           "lvlh" : "Spacecraft LVLH Frame",
           "pos_sc_pci" : "Position",
           "vel_sc_pci" : "Velocity",
           "quat_sc_pci" : "Attitude",
           "ang_vel_sc_pci__body" : "Ang. Vel.",
           "latitude_detic" : "Latitude",
           "longitude" : "Longitude",
           "altitude_detic" : "Altitude",
           "planet_ptr" : "Planet",
           "inertia" : "EXCLUDE",
           "mass" : "Mass"
}
*/
 
#ifndef MODELS_ASSEMBLIES_SPACECRAFT_H
#define MODELS_ASSEMBLIES_SPACECRAFT_H
 
#include "core/CartesianVector.hpp"
#include "frames/Body.h"
#include "frames/Node.h"
#include "models/states/FrameStateSensorModel.h"
#include "models/environment/AsphericalGravityModel.h"
#include "models/environment/SphericalHarmonicsGravityModel.h"
#include "models/assemblies/CustomPlanet.h"
#include "models/assemblies/SpicePlanet.h"
#include "models/states/PlanetRelativeStatesModel.h"
#include "models/environment/GravityGradientModel.h"
#include "models/support/LvlhFrameManagerModel.h"
#include "models/actuators/TimedImpulsiveBurnModel.h"
#include "constants/planetdefaults.h"
#include "models/environment/MSISAtmosphereModel.h"
#include "models/actuators/FlatPlateDragModel.h"
 
namespace warptwin {
 
    class Executive;

    MODEL(Spacecraft)
    public:
        // Model params
        //         NAME                     TYPE                    DEFAULT VALUE
        START_PARAMS
            SIGNAL(mass,                    double,                 1.0)
            SIGNAL(inertia,                 Matrix3,               Matrix3({{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}}))
            SIGNAL(initial_position,        CartesianVector3,      CartesianVector3({0.0,0.0,0.0}))
            SIGNAL(initial_velocity,        CartesianVector3,      CartesianVector3({0.0,0.0,0.0}))
            SIGNAL(pos_vel_init_frame,      Frame*,                nullptr)
            SIGNAL(initial_attitude,        clockwerk::Quaternion, clockwerk::Quaternion({1.0,0.0,0.0,0.0}))
            SIGNAL(initial_ang_vel,         CartesianVector3,      CartesianVector3({0.0,0.0,0.0}))
            SIGNAL(att_init_frame,          Frame*,                nullptr)
            SIGNAL(planet_ptr,              GraphTreeObject*,       nullptr)
        END_PARAMS
 
        // Model inputs
        //         NAME                     TYPE                    DEFAULT VALUE
        START_INPUTS
        END_INPUTS
 
        // Model outputs
        //         NAME                     TYPE                    DEFAULT VALUE
        START_OUTPUTS
            SIGNAL(body,                    Frame*,                nullptr)
            SIGNAL(lvlh,                    Frame*,                nullptr)
            SIGNAL(pos_sc_pci,              CartesianVector3,      CartesianVector3({0.0, 0.0, 0.0}))
            SIGNAL(vel_sc_pci,              CartesianVector3,      CartesianVector3({0.0, 0.0, 0.0}))
            SIGNAL(quat_sc_pci,             clockwerk::Quaternion, clockwerk::Quaternion({1.0, 0.0, 0.0, 0.0}))
            SIGNAL(ang_vel_sc_pci__body,    CartesianVector3,      CartesianVector3({0.0, 0.0, 0.0}))
            SIGNAL(latitude_detic,          double,                 0.0)
            SIGNAL(longitude,               double,                 0.0)
            SIGNAL(altitude_detic,          double,                 0.0)
            SIGNAL(total_power_in,          double,                 0.0)
            SIGNAL(total_power_out,         double,                 0.0)
        END_OUTPUTS

        int initializePositionVelocity(CartesianVector3 position_sc_frame__frame,
                                       CartesianVector3 velocity_sc_frame__frame,
                                       Frame* frame_ptr=nullptr);

        int initializePositionVelocity(CartesianVector3 position_sc_frame__frame,
                                       CartesianVector3 velocity_sc_frame__frame,
                                       const std::string &frame_name);

        int initializeFromOrbitalElements(double a, double e, double i, double RAAN, double w, double f);

        int initializeAttitude(clockwerk::Quaternion quat_sc_frame__frame,
                               CartesianVector3 ang_vel_sc_frame__sc,
                               Frame* frame_ptr=nullptr);

        int initializeAttitude(clockwerk::Quaternion quat_sc_frame__frame,
                               CartesianVector3 ang_vel_sc_frame__sc,
                               const std::string &frame_name);

        warptwin::TimedImpulsiveBurnModel* programManeuver(CartesianVector3 delta_v__f,
                                                             std::string time_string,
                                                             Frame* force_frame_ptr);
        warptwin::TimedImpulsiveBurnModel* programManeuver(CartesianVector3 delta_v__f,
                                                             double sim_time,
                                                             Frame* force_frame_ptr);

        int addPowerLoad(clockwerk::DataIO<double>* power_load_ptr);

        void clearPowerLoads() {_power_load_ptrs.clear();}

        int addPowerSource(clockwerk::DataIO<double>* power_source_ptr);

        void clearPowerSources() {_power_source_ptrs.clear();}
 
        // Accessor for our spacecraft body
        clockwerk::DataIO<Body*> body = clockwerk::DataIO<Body*>(this, "body", &_body);
 
        // Accessor for our spacecraft lvlh frame
        clockwerk::DataIO<Body*> lvlh = clockwerk::DataIO<Body*>(this, "lvlh", nullptr);

        warptwin::FrameStateSensorModel* planetInertialStateSensor() {return &_planet_inertial_state_sensor;}
        warptwin::FrameStateSensorModel* planetRotatingStateSensor() {return &_planet_rotating_state_sensor;}
        warptwin::LvlhFrameManagerModel* lvlhFrameManager() {return &_lvlh_frame_manager;}
        warptwin::AsphericalGravityModel* asphericalGravityModel() {return _asp_ptr;}
        warptwin::SphericalHarmonicsGravityModel* sphericalHarmGravityModel() {return _sph_ptr;}
        warptwin::PlanetRelativeStatesModel* planetRelativeModel() {return &_planet_relative;}
        warptwin::GravityGradientModel* gravityGradientModel() {return &_gravity_gradient;}
        warptwin::MSISAtmosphereModel* msisModel() {return _msis_ptr;}
        warptwin::FlatPlateDragModel* atmosDrag() {return &_atmos_drag;}
    protected:
        int16 start() override;
        int16 execute() override;

        int _configureFromPlanet();

        void _mapInternal();

        void _calculatePowerAccumulation();
 
        // Spacecraft body
        Body _body;
        Node _gravity_node;
        Node _drag_node;
 
        // Models included within the Spacecraft class
        FrameStateSensorModel _planet_inertial_state_sensor;
        FrameStateSensorModel _planet_rotating_state_sensor;
        LvlhFrameManagerModel _lvlh_frame_manager;
        GravityGradientModel _gravity_gradient;
        PlanetRelativeStatesModel _planet_relative;
        FlatPlateDragModel _atmos_drag;
 
        // Pointers to models which are declared on the basis of the spacecraft
        // model type
        AsphericalGravityModel* _asp_ptr = nullptr;
        SphericalHarmonicsGravityModel* _sph_ptr = nullptr;
        MSISAtmosphereModel* _msis_ptr = nullptr;
 
        // Internal signals for the mapping of planet values to spacecraft
        SIGNAL(_mu, double, warpos::earth_wgs84.mu);
        SIGNAL(_eq_radius, double, warpos::earth_wgs84.eq_radius);
        SIGNAL(_flattening, double, warpos::earth_wgs84.flattening);
        SIGNAL(_J2, double, warpos::earth_wgs84.J2);
        SIGNAL(_J3, double, warpos::earth_wgs84.J3);
        std::string _planet_name = "earth";
 
        // Vector of programmed burn models
        std::vector<TimedImpulsiveBurnModel*> _planned_burn_ptrs;
 
        // Vector of power loads from components (Watts)
        std::vector<clockwerk::DataIO<double>*> _power_load_ptrs;
 
        // Vector of power sources from components (Watts)
        std::vector<clockwerk::DataIO<double>*> _power_source_ptrs;
    };
 
}
 
#endif