LambertTargetTask.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.
******************************************************************************/
/*
Simple PID header file
 
Author: Alex Reynolds
*/
 
#ifndef GNC_GUIDANCE_LAMBERT_TARGET_TASK_H
#define GNC_GUIDANCE_LAMBERT_TARGET_TASK_H
 
#include "core/macros.h"
#include "architecture/Tasks.h"
#include "six_dof_dynamics/Frame.hpp"
#include "utils/frameutils.hpp"
 
namespace clockwerk {
    /**
     * @brief   Lambert impulsive targeting task
     * 
     * This task implements a lambert targeter which, given a "target" and "chaser"
     * state at the current time and a time to intercept calculates the delta v
     * required of the chaser to intercept the target. The task uses two key steps
     * internally: first, it propgates the target state forward to the intercept
     * time using a keplerian two body dynamics propagator. Next, it solves for the
     * delta V required of the chaser to achieve that position at the exact same
     * time using an iterative lambert solver which implements Battin's method.
     * 
     * The solver only runs when trigger is true. Otherwise, it remains idle. All
     * outputs will reflect the solution calculated on a previous trigger (i.e. will
     * not be wiped clean, even when trigger is false.)
     * 
     * Key assumptions:
     * - The target and chaser are both under the influence of two body dynamics
     *   with the same central body
     * - The solver is impulsive and does not account for thrust/timing effects
     * - The desired intercept solution is elliptical, not hyperbolic
     * 
     * Author: Alex Reynolds <alex.reynolds@attx.tech>
    */
    class LambertTargetTask : public clockwerk::Task {
    public:
        // Model params
        //         NAME                     TYPE                    DEFAULT VALUE
        START_PARAMS
            /** The minimum dv below which the lambert targeter will round dv to 0. Effectively deadband. */
            SIGNAL(minimum_delta_v,         double,                 0.0)
            /** The graviational parameter of the central body */
            SIGNAL(mu,                      double,                 3.986004418e+14)
            /** The minimum tolerance to which the lambert solver will iteratively solve */
            SIGNAL(lambert_solver_tolerance,double,                 1e-12)
            /** The maximum iterations within the lambert solver before exit */
            SIGNAL(lambert_solver_max_iter, int,                    10)
        END_PARAMS
 
        // Model inputs
        //         NAME                     TYPE                    DEFAULT VALUE
        START_INPUTS
            /** Flag to trigger the lambert targeter to run and target. Should be true (1) to 
             *  trigger, false (0) for idle. */
            SIGNAL(trigger,                 int,                    false)
            /** The time delta, relative to current time, at which the targeter will target
             *  intercept of the target. Delta V will be generated to intercept at this time. */
            SIGNAL(time_to_intercept,       double,                 0.0)
            /** The current position of the target relative to a planet inertial frame */
            SIGNAL(target_pos_inertial,     CartesianVector3D,      CartesianVector3D({0.0,0.0,0.0}))
            /** The current velocity of the target relative to a planet inertial frame */
            SIGNAL(target_vel_inertial,     CartesianVector3D,      CartesianVector3D({0.0,0.0,0.0}))
            /** The current position of the chaser spacecraft relative to a planet inertial frame */
            SIGNAL(chaser_pos_inertial,     CartesianVector3D,      CartesianVector3D({0.0,0.0,0.0}))
            /** The current velocity of the chaser spacecraft relative to a planet inertial frame */
            SIGNAL(chaser_vel_inertial,     CartesianVector3D,      CartesianVector3D({0.0,0.0,0.0}))
        END_INPUTS
 
        // Model outputs
        //         NAME                     TYPE                    DEFAULT VALUE
        START_OUTPUTS
            /** The instantaneous delta v necessary to achieve chaser intercept with target after time seconds */
            SIGNAL(delta_v,                 CartesianVector3D,      CartesianVector3D({0.0,0.0,0.0}))
            /** The position, in planet inertial coordinates, at which intercept will occur */
            SIGNAL(pos_intercept_inertial,  CartesianVector3D,      CartesianVector3D({0.0,0.0,0.0}))
            /** The difference in velocity between the target and chaser at the intercept point as (target - chaser)*/
            SIGNAL(dv_intercept,            CartesianVector3D,      CartesianVector3D({0.0,0.0,0.0}))
        END_OUTPUTS
 
        // Model-specific implementations of startup and derivative
        LambertTargetTask() : clockwerk::Task() {}
        LambertTargetTask(clockwerk::Task &pnt, int schedule_slot=0, const std::string &m_name="lambert_target_task")
            : clockwerk::Task(pnt, schedule_slot, m_name) {}
        LambertTargetTask(clockwerk::Executive &e, int schedule_slot=0, const std::string &m_name="lambert_target_task")
            : clockwerk::Task(e, schedule_slot, m_name) {}
        virtual ~LambertTargetTask() {}
    protected:
        int execute();
 
        // The position and velocity of our target and chaser at the future time, when propagated
        CartesianVector3D _pos_tgt_intercept;
        CartesianVector3D _vel_tgt_intercept;
        CartesianVector3D _vel_chaser_intercept;
 
        // The v1 and v2 values returned by our lambert solver -- chaser velocity at initial and final position
        CartesianVector3D _vel_chaser_initial;
        CartesianVector3D _vel_chaser_final;
 
        // Our delta V vector
        CartesianVector3D _delta_v;
 
        // We don't really care about these, but semimajor axis and semi latus rectum of intercept orbit
        double _a;
        double _p;
    };
 
}
 
#endif