boinor.core.propagation.gooding
===============================

.. py:module:: boinor.core.propagation.gooding

.. autoapi-nested-parse::

   module related to propagation of an orbit using Gooding's method in the core sub-package



Functions
---------

.. autoapisummary::

   boinor.core.propagation.gooding.gooding_coe_parabolic
   boinor.core.propagation.gooding.gooding_coe_hyperbolic
   boinor.core.propagation.gooding.gooding_coe_elliptic
   boinor.core.propagation.gooding.gooding_coe
   boinor.core.propagation.gooding.gooding


Module Contents
---------------

.. py:function:: gooding_coe_parabolic(k, p, ecc, inc, raan, argp, nu, tof, numiter=150, rtol=1e-08)

   not yet implemented propagation with Gooding's method for parabolic case


.. py:function:: gooding_coe_hyperbolic(k, p, ecc, inc, raan, argp, nu, tof, numiter=150, rtol=1e-08)

   not yet implemented propagation with Gooding's method for hyperbolic case


.. py:function:: gooding_coe_elliptic(k, p, ecc, inc, raan, argp, nu, tof, numiter=150, rtol=1e-08)

   This function contains EKEPL1 from appendix A of :cite:t:`Walker1985`
   As mentioned in this paper, it uses a Legendre based starter and a
   Halley iterator


.. py:function:: gooding_coe(k, p, ecc, inc, raan, argp, nu, tof, numiter=150, rtol=1e-08)

   This function is just a wrapper for the correct ecc handling.


.. py:function:: gooding(k, r0, v0, tof, numiter=150, rtol=1e-08)

   Solves the Elliptic Kepler Equation with a cubic convergence and
   accuracy better than 10e-12 rad is normally achieved. It is not valid for
   eccentricities equal or higher than 1.0.

   :param k: Standard gravitational parameter of the attractor.
   :type k: float
   :param r0: Position vector.
   :type r0: numpy.ndarray
   :param v0: Velocity vector.
   :type v0: numpy.ndarray
   :param tof: Time of flight.
   :type tof: float
   :param numiter: Number of iterations, defaults to 150.
   :type numiter: int, optional
   :param rtol: Relative error for accuracy of the method, defaults to 1e-8.
   :type rtol: float, optional

   :returns: * **rr** (*numpy.ndarray*) -- Final position vector.
             * **vv** (*numpy.ndarray*) -- Final velocity vector.

   .. note::

      Original paper for the algorithm: https://doi.org/10.1007/BF01238923
      This is :cite:t:`Walker1985`.