ForwardEulerIntegrator.hpp

/******************************************************************************
* 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.
******************************************************************************/
/*
Forward Euler header file
-------------------------
 
 
Author: Alex Reynolds
*/
#ifndef FORWARD_EULER_HPP
#define FORWARD_EULER_HPP
 
#include <array>
 
#include "Rates.hpp"
#include "Integrator.hpp"
 
namespace clockwerk {
 
    template <typename T, unsigned int N>
    class ForwardEulerIntegrator : public Integrator<T, N> {
    public:
        ForwardEulerIntegrator(Rates<T, N>& rate_calculator);
 
        /// Function to step the integrator forward from time start to time end
        /// @param   start_time      Start time for integration
        /// @param   end_time        End time for integration
        /// @param   start_state     State at start of integration
        /// @param   out_state       Output state via implicit -- result of integration
        void step(T start_time, T end_time, const std::array<T, N> &start_state, std::array<T, N> &out_state);
    protected:
        /// Step size for integrator
        T _step_size;
 
        std::array<T, N> _rates;
    };
 
    template <typename T, unsigned int N>
    ForwardEulerIntegrator<T, N>::ForwardEulerIntegrator(Rates<T, N>& rate_calculator)
        : Integrator<T, N>(rate_calculator) {
        _step_size = 0.0;
        for(unsigned int i = 0; i < N; i++) {
            _rates[i] = 0.0;
        }
    }
 
    template <typename T, unsigned int N>
    void ForwardEulerIntegrator<T, N>::step(T start_time, T end_time,
                                            const std::array<T, N> &start_state,
                                            std::array<T, N> &out_state) {
        /// Calculate rate of change in the system based on time, state
        Integrator<T, N>::_rate_calculator.calculateRates(start_time, start_state, _rates);
 
        /// Now update our output state given our rate and time step size
        _step_size = end_time - start_time;
        for(unsigned int i = 0; i < N; i++) {
            out_state[i] = start_state[i] + _step_size*_rates[i];
        }
    }
 
}
 
#endif