boinor.maneuver
===============

.. py:module:: boinor.maneuver

.. autoapi-nested-parse::

   Orbital maneuvers.



Classes
-------

.. autoapisummary::

   boinor.maneuver.Maneuver


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

.. py:class:: Maneuver(*impulses)

   Class to represent a Maneuver.

   Each ``Maneuver`` consists on a list of impulses :math:`\Delta v_i`
   (changes in velocity) each one applied at a certain instant :math:`t_i`.
   You can access them directly indexing the ``Maneuver`` object itself.

   >>> man = Maneuver((0 * u.s, [1, 0, 0] * u.km / u.s),
   ... (10 * u.s, [1, 0, 0] * u.km / u.s))
   >>> man[0]
   (<Quantity 0. s>, <Quantity [1., 0., 0.] km / s>)
   >>> man.impulses[1]
   (<Quantity 10. s>, <Quantity [1., 0., 0.] km / s>)



   .. py:attribute:: impulses


   .. py:method:: __repr__()


   .. py:method:: __getitem__(key)


   .. py:method:: impulse_has_valid_units(dts, dvs)
      :staticmethod:


      make sure that all parameters dts and dvs have the correct unit



   .. py:method:: impulse(dv)
      :classmethod:


      Single impulse at current time.

      :param dv: Velocity components of the impulse.
      :type dv: numpy.ndarray



   .. py:method:: hohmann(orbit_i, r_f)
      :classmethod:


      Compute a Hohmann transfer between two circular orbits.

      :param orbit_i: Initial orbit
      :type orbit_i: boinor.twobody.orbit.Orbit
      :param r_f: Final orbital radius
      :type r_f: astropy.unit.Quantity



   .. py:method:: bielliptic(orbit_i, r_b, r_f)
      :classmethod:


      Compute a bielliptic transfer between two circular orbits.

      :param orbit_i: Initial orbit
      :type orbit_i: boinor.twobody.orbit.Orbit
      :param r_b: Altitude of the intermediate orbit
      :type r_b: astropy.unit.Quantity
      :param r_f: Final orbital radius
      :type r_f: astropy.unit.Quantity



   .. py:method:: lambert(orbit_i, orbit_f, method=lambert_izzo, **kwargs)
      :classmethod:


      Computes Lambert maneuver between two different points.

      :param orbit_i: Initial orbit
      :type orbit_i: ~boinor.twobody.Orbit
      :param orbit_f: Final orbit
      :type orbit_f: ~boinor.twobody.Orbit
      :param method: Method for solving Lambert's problem
      :type method: function
      :param \*\*kwargs: Extra kwargs for Lambert method.



   .. py:method:: get_total_time()

      Returns total time of the maneuver (s).



   .. py:method:: get_total_cost()

      Returns total cost of the maneuver (km / s).



   .. py:method:: get_total_cost_optimized()

      Returns total cost of the maneuver (km / s) in optimized version.



   .. py:method:: correct_pericenter(orbit, max_delta_r)
      :classmethod:


      Returns a Maneuver with the time before burning and the velocity vector in direction of the burn.

      :param orbit: Position and velocity of a body with respect to an attractor
                    at a given time (epoch).
      :type orbit: Orbit
      :param max_delta_r: Maximum satellite’s geocentric distance
      :type max_delta_r: ~astropy.units.Quantity

      :returns: **maneuver** -- Maneuver with the maximum time before we do an orbit-adjustment burn to restore the perigee to its
                nominal value and the velocity vector of the spacecraft to achieve the desired correction.
      :rtype: Maneuver

      :raises NotImplementedError: - If the correction maneuver is not implemented for the attractor.
          - if the eccentricity is greater than 0.001.