ForwardEulerIntegrator.hpp

Go to the documentation of this file.

/******************************************************************************
* 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 UTILS_FORWARD_EULER_HPP
#define UTILS_FORWARD_EULER_HPP
 
#include <array>
 
#include "gncutils/dynamics/Rates.hpp"
#include "Integrator.hpp"
 
namespace warpos {
 
    template <uint32 N>
    class ForwardEulerIntegrator : public Integrator<N> {
    public:
        ForwardEulerIntegrator(Rates<N>& rate_calculator);

        int16 step(floating_point start_time, 
                  floating_point end_time, 
                  const std::array<floating_point, N> &start_state, 
                  std::array<floating_point, N> &out_state) override;
    protected:
        floating_point _step_size = 1.0;

        int16 _error = NO_ERROR;
 
        std::array<floating_point, N> _rates;
    };
 
    template <uint32 N>
    ForwardEulerIntegrator<N>::ForwardEulerIntegrator(Rates<N>& rate_calculator) 
        : Integrator<N>(rate_calculator) {
        _step_size = 0.0;
        for(uint32 i = 0; i < N; i++) {
            _rates[i] = 0.0;
        }
    }
 
    template <uint32 N>
    int16 ForwardEulerIntegrator<N>::step(floating_point start_time, floating_point end_time, 
                                         const std::array<floating_point, N> &start_state, 
                                         std::array<floating_point, N> &out_state) {
        _error = Integrator<N>::_rate_calculator.calculateRates(start_time, start_state, _rates);

        _step_size = end_time - start_time;
        for(uint32 i = 0; i < N; i++) {
            out_state[i] = start_state[i] + _step_size*_rates[i];
        }
        return _error;
    }
 
}
 
#endif