    Integrate an ode for a FullOrbit for integrate_sos

    Parameters
    ----------
    pot : Potential or list of such instances
        The potential (or list thereof) to evaluate the orbit in.
    yo : numpy.ndarray
        Initial condition [q,p], shape [N,5] or [N,6]
    psi : numpy.ndarray
        Set of increment angles at which one wants the result [increments wrt initial angle]
    t0 : float or numpy.ndarray
        Initial time
    int_method : str
        Integration method. One of 'leapfrog', 'odeint', or 'dop853'
    rtol : float, optional
        Relative tolerance. Default is None.
    atol : float, optional
        Absolute tolerance. Default is None.
    numcores : int, optional
        Number of cores to use for multi-processing. Default is 1.
    progressbar : bool, optional
        If True, display a tqdm progress bar when integrating multiple orbits (requires tqdm to be installed!). Default is True.
    dpsi : float, optional
        Force integrator to use this stepsize (default is to automatically determine one; only for C-based integrators). Default is None.

    Returns
    -------
    tuple
        (y,err)
        y : array, shape (N,len(psi),6/7) where the last of the last dimension is the time
            Array containing the value of y for each desired angle in psi, with the initial value y0 in the first row.
        err : float
            Error message, always zero for now

    Notes
    -----
    - 2023-03-16 - Written based on integrateFullOrbit - Bovy (UofT)


    Implements the EOM, i.e., the right-hand side of the differential equation, for a 3D orbit assuming conservation of angular momentum.

    Parameters
    ----------
    y : list or numpy.ndarray
        Current phase-space position.
    t : float
        Current time.
    pot : list of Potential instance(s)
        Potential instance(s).
    l2 : float
        Angular momentum squared.

    Returns
    -------
    list
        Derivative of the phase-space position.

    Notes
    -----
    - 2010-04-16 - Written - Bovy (NYU).


    Implements the EOM, i.e., the right-hand side of the differential equation, for a 3D orbit.

    Parameters
    ----------
    y : list or numpy.ndarray
        Current phase-space position.
    t : float
        Current time.
    pot : list of Potential instance(s)
        Potential instance(s).

    Returns
    -------
    list
        Derivative of the phase-space position.

    Notes
    -----
    - 2010-04-16 - Written - Bovy (NYU)


    Implements the EOM, i.e., the right-hand side of the differential equation, for the SOS integration of a 3D orbit

    Parameters
    ----------
    y : numpy.ndarray
        Current phase-space position
    psi : float
        Current angle
    pot : list of Potential instance(s)
        Potential instance(s)

    Returns
    -------
    numpy.ndarray
        dy/dpsi

    Notes
    -----
    - 2023-03-16 - Written - Bovy (UofT)


    Returns the force in the rectangular frame

    Parameters
    ----------
    x : numpy.ndarray
        Current position
    t : float, optional
        Current time (default is 0.0)
    pot : (list of) Potential instance(s)
        The potential (or list thereof) to evaluate the force for
    vx : numpy.ndarray, optional
        If set, use this [vx,vy,vz] when evaluating dissipative forces (default is None)

    Returns
    -------
    numpy.ndarray
        The force in the rectangular frame

    Notes
    -----
    - 2011-02-02 - Written - Bovy (NYU)


Decorator to return Orbits outputs with the correct shape


        Construct an orbit from the name of an object or a list of names.

        Parameters
        ----------
        name : str or list
            The name of the object or list of names. When loading a collection of objects (like 'mwglobularclusters'), lists are not allowed.
        ro : float or Quantity, optional
            Distance from vantage point to Galactic center (kpc).
        vo : float or Quantity, optional
            Circular velocity at ro (km/s; can be Quantity).
        zo : float or Quantity, optional
            Offset toward the NGP of the Sun wrt the plane in kpc; default = 20.8 pc from Bennett & Bovy 2019).
        solarmotion : str, numpy.ndarray or Quantity, optional
            Solar motion. Can be 'hogg' or 'dehnen', or 'schoenrich', or value in [-U,V,W] in km/s.

        Returns
        -------
        Orbit
            An orbit containing the phase space coordinates of the named object.

        Notes
        -----
        - 2018-07-15: Written - Mathew Bub (UofT)
        - 2019-05-21: Generalized to multiple objects and incorporated into Orbits - Bovy (UofT)


        Initialize an Orbit using a fit to data.

        Parameters
        ----------
        init_vxvv : numpy.ndarray
            Initial guess for the fit (same representation [e.g.,radec=True] as vxvv data, except when customsky, then init_vxvv is assumed to be ra,dec).
        vxvv : numpy.ndarray
            [:,6] array of positions and velocities along the orbit (if not lb=True or radec=True, these need to be in natural units [/ro,/vo], cannot be Quantities).
        vxvv_err : numpy.ndarray, optional
            [:,6] array of errors on positions and velocities along the orbit (if None, these are set to 0.01) (if not lb=True or radec=True, these need to be in natural units [/ro,/vo], cannot be Quantities).
        pot : Potential, DissipativeForce, or list of such instances, optional
            Gravitational field to integrate orbits in.

        radec : bool, optional
            If set, treat input as being in ICRS coordinates [ra,dec,d,mu_ra, mu_dec,vlos] in [deg,deg,kpc,mas/yr,mas/yr,km/s] (mu_ra = mu_ra * cos dec).
        lb : bool, optional
            If set, treat input as being in Galactic coordinates (l,b,d,mu_l, mu_b, vlos) in [deg,deg,kpc,mas/yr,mas/yr,km/s) (mu_l = mu_l * cos b).
        customsky : bool, optional
            If True, input vxvv and vxvv_err are [custom long,custom lat,d,mu_customll, mu_custombb,vlos] in [deg,deg,kpc,mas/yr,mas/yr,km/s] (mu_ll = mu_ll * cos lat) where custom longitude and custom latitude are a custom set of sky coordinates (e.g., ecliptic) and the proper motions are also expressed in these coordinates; you need to provide the functions lb_to_customsky and pmllpmbb_to_customsky to convert to the custom sky coordinates (these should have the same inputs and outputs as lb_to_radec and pmllpmbb_to_pmrapmdec); the attributes of the current Orbit are used to convert between these coordinates and Galactocentric coordinates.
        lb_to_customsky : function, optional
            Function that converts l,b,degree=False to the custom sky coordinates (like lb_to_radec); needs to be given when customsky=True.
        pmllpmbb_to_customsky : function, optional
            Function that converts pmll,pmbb,l,b,degree=False to proper motions in the custom sky coordinates (like pmllpmbb_to_pmrapmdec); needs to be given when customsky=True.

        tintJ : float, optional
            Time to integrate orbits for fitting the orbit (can be Quantity).
        ntintJ : int, optional
            Number of time-integration points.
        integrate_method : str, optional
            Integration method to use (default: 'dopr54_c'; see galpy.orbit.Orbit.integrate).

        ro : float or Quantity, optional
            Distance from vantage point to Galactic center (kpc).
        vo : float or Quantity, optional
            Circular velocity at ro (km/s; can be Quantity).
        zo : float or Quantity, optional
            Offset toward the NGP of the Sun wrt the plane in pc; default = 20.8 pc from Bennett & Bovy 2019).
        solarmotion : str, numpy.ndarray or Quantity, optional
            'hogg' or 'dehnen', or 'schoenrich', or value in [-U,V,W] in km/s.

        disp : bool, optional
            Display the optimizer's convergence message.

        Returns
        -------
        Orbit
            An orbit that is the best fit to the given data.

        Notes
        -----
        - 2014-06-17 - Written - Bovy (IAS)
        - 2019-05-22 - Incorporated into new Orbit class as from_fit -  Bovy (UofT)

        See Also
        --------
        galpy.orbit.Orbit.integrate


        Return the dimension of the Orbit.

        Returns
        -------
        int
            Dimension of the orbit.

        Notes
        -----
        - 2011-02-03 - Written - Bovy (NYU)


        Return the phase-space dimension of the problem.

        Returns
        -------
        int
            Phase-space dimension (2 for 1D, 3 for 2D-axi, 4 for 2D, 5 for 3D-axi, 6 for 3D).

        Notes
        -----
        - 2018-12-20: Written by Bovy (UofT).


        Change the shape of the Orbit instance.

        Parameters
        ----------
        newshape : int or tuple of ints
            New shape (see numpy.reshape).

        Returns
        -------
        None
            Re-shaping is done in-place.

        Notes
        -----
        - 2019-03-20: Written by Bovy (UofT).


        Turn off automatic returning of outputs in physical units.

        Parameters
        ----------
        None

        Returns
        -------
        None

        Notes
        -----
        - 2019-02-28 - Written - Bovy (UofT)


        Turn on automatic returning of outputs in physical units.

        Parameters
        ----------
        ro : float, Quantity or bool, optional
            Physical scale in kpc for distances to use to convert. If False, do not set.
        vo : float, Quantity or bool, optional
            Physical scale for velocities in km/s to use to convert. If False, do not set.

        Returns
        -------
        None

        Notes
        -----
        - 2019-02-28: Written by Bovy (UofT).
        - 2020-04-22: Don't turn on a parameter when it is False - Bovy (UofT).


        Integrate this Orbit instance using an independent variable suitable to creating surfaces-of-section.

        Parameters
        ----------
        psi : list, numpy.ndarray or Quantity
            Equispaced list of increment angles over which to integrate [increments wrt initial angle].  (note that for method='odeint', method='dop853', and method='dop853_c', the psi array can be non-equispaced).
        pot : Potential, DissipativeForce or list of such instances
            Gravitational field to integrate the orbit in.
        surface : str, optional
            Surface to punch through (this has no effect in 3D, where the surface is always z=0, but in 2D it can be 'x' or 'y' for x=0 or y=0).
        t0 : float or Quantity, optional
            Initial time.
        method : {'odeint', 'dop853_c', 'dop853', 'rk4_c', 'rk6_c', 'dop54_c'}, optional
            Integration method to use. Default is 'dop853_c'. See Notes for more information.
        progressbar : bool, optional
            If True, display a tqdm progress bar when integrating multiple orbits (requires tqdm to be installed!).
        numcores : int, optional
            Number of cores to use for Python-based multiprocessing (pure Python or using force_map=True); default = OMP_NUM_THREADS.
        force_map : bool, optional
            If True, force use of Python-based multiprocessing (not recommended).

        Returns
        -------
        None
            Get the actual orbit using getOrbit() or access the individual attributes (e.g., R, vR, etc.).

        Notes
        -----
        - Possible integration methods are:

          - 'odeint' for scipy's odeint
          -  'rk4_c' for a 4th-order Runge-Kutta integrator in C
          -  'rk6_c' for a 6-th order Runge-Kutta integrator in C
          -  'dopr54_c' for a 5-4 Dormand-Prince integrator in C
          -  'dop853' for a 8-5-3 Dormand-Prince integrator in Python
          -  'dop853_c' for a 8-5-3 Dormand-Prince integrator in C

        - 2023-03-16 - Written - Bovy (UofT)


r"""
        Integrate the orbit and a small area of phase space.

        Parameters
        ----------
        dxdv : numpy.ndarray
            Initial conditions for the orbit in cylindrical or rectangular coordinates. The shape of the array should be (\*input_shape, 4).
        t : list, numpy.ndarray or Quantity
            List of equispaced times at which to compute the orbit. The initial condition is t[0].  (note that for method='odeint', method='dop853', and method='dop853_c', the time array can be non-equispaced).
        pot : Potential, DissipativeForce or list of such instances
            Gravitational field to integrate the orbit in.
        method : str, optional
            Integration method. Default is 'dopr54_c'. See Notes for more information.
        progressbar : bool, optional
            If True, display a tqdm progress bar when integrating multiple orbits (requires tqdm to be installed!). Default is True.
        dt : float, optional
            If set, force the integrator to use this basic stepsize; must be an integer divisor of output stepsize (only works for the C integrators that use a fixed stepsize) (can be Quantity).
        numcores : int, optional
            Number of cores to use for Python-based multiprocessing (pure Python or using force_map=True); default = OMP_NUM_THREADS.
        force_map : bool, optional
            If True, force use of Python-based multiprocessing (not recommended). Default is False.
        rectIn : bool, optional
            If True, input dxdv is in rectangular coordinates. Default is False.
        rectOut : bool, optional
            If True, output dxdv (that in orbit_dxdv) is in rectangular coordinates. Default is False.

        Returns
        -------
        None
            Get the actual orbit using getOrbit_dxdv(), the orbit that is integrated alongside with dxdv is stored as usual, any previous regular orbit integration will be erased!

        Notes
        -----
        - Possible integration methods are the non-symplectic ones in galpy:

          - 'odeint' for scipy's odeint
          -  'rk4_c' for a 4th-order Runge-Kutta integrator in C
          -  'rk6_c' for a 6-th order Runge-Kutta integrator in C
          -  'dopr54_c' for a 5-4 Dormand-Prince integrator in C
          -  'dop853' for a 8-5-3 Dormand-Prince integrator in Python
          -  'dop853_c' for a 8-5-3 Dormand-Prince integrator in C

        - 2011-10-17 - Written - Bovy (IAS)
        - 2014-06-29 - Added rectIn and rectOut - Bovy (IAS)
        - 2019-05-21 - Parallelized and incorporated into new Orbits class - Bovy (UofT)


        Flip an orbit's initial conditions such that the velocities are minus the original velocities.

        Parameters
        ----------
        inplace : bool, optional
            If True, flip the orbit in-place, that is, without returning a new instance and also flip the velocities of the integrated orbit (if it exists). Default is False.

        Returns
        -------
        Orbit
            If inplace=False, returns a new Orbit instance that has the velocities of the current orbit flipped. If inplace=True, flips all velocities of current instance.

        Notes
        -----
        - 2019-03-02 - Written - Bovy (UofT)


r"""
        Calculate the energy.

        Parameters
        ----------
        t : numeric, numpy.ndarray, or Quantity, optional
            Time at which to get the energy. Default is the initial time.
        pot : Potential, DissipativeForce or list of such instances, optional
            Gravitational potential to use to compute the energy (DissipativeForce instances are ignored). Default is the gravitational field used to integrate the orbit.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Energy.

        Notes
        -----
        - 2019-03-01 - Written - Bovy (UofT)


r"""
        Calculate the angular momentum at time t.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the angular momentum. Default is the initial time.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt,3]
            Angular momentum.

        Notes
        -----
        - 2019-03-01 - Written - Bovy (UofT)


r"""
        Calculate the z-component of the angular momentum at time t.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the angular momentum. Default is the initial time.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            z-component of the angular momentum.

        Notes
        -----
        - 2019-03-01 - Written - Bovy (UofT)


r"""
        Calculate the radial energy.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the radial energy. Default is the initial time.
        pot : Potential, DissipativeForce or list of such instances
            Gravitational potential to use for the calculation (DissipativeForce instances are ignored). Default is the gravitational field used to integrate the orbit.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Radial energy.

        Notes
        -----
        - 2019-03-01 - Written - Bovy (UofT)


r"""
        Calculate the vertical energy.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the vertical energy. Default is the initial time.
        pot : Potential, DissipativeForce or list of such instances
            Gravity potential to use for the calculation (DissipativeForce instances are ignored). Default is the gravitational field used to integrate the orbit.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Vertical energy.

        Notes
        -----
        - 2019-03-01 - Written - Bovy (UofT)


r"""
        Calculate the Jacobi integral E - Omega L.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the Jacobi integral. Default is the initial time.
        OmegaP : numeric or Quantity, optional
            Pattern speed.
        pot : Potential, DissipativeForce or list of such instances
            Gravity potential to use for the calculation (DissipativeForce instances are ignored). Default is the gravitational field used to integrate the orbit.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Jacobi integral.

        Notes
        -----
        - 2019-03-01 - Written - Bovy (UofT)


        Set up an actionAngle module for this Orbit.

        Parameters
        ----------
        pot : Potential or list of Potentials, optional
            Gravitational potential to use for the calculation (DissipativeForce instances are ignored). Default is the gravitational field used to integrate the orbit.
        type : {'staeckel', 'adiabatic', 'spherical', 'isochroneApprox'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
            Options are:
                1) 'adiabatic'
                2) 'staeckel'
                3) 'isochroneApprox'
                4) 'spherical'

        Returns
        -------
        None

        Notes
        -----
        - 2019-02-25 - Written based on OrbitTop._setupaA - Bovy (UofT)


Internal function to compute the index of unbound orbits


Internal function to compute e,zmax,rperi,rap and cache it for reuse


Internal function to compute the actions, frequencies, and angles and cache them for reuse


Internal function to compute the actions and cache them for reuse (used for methods that don't support frequencies and angles)


r"""
        Calculate the eccentricity, either numerically from the numerical orbit integration or using analytical means.

        Parameters
        ----------
        analytic : bool, optional
            If True, compute this analytically. Default is False.
        pot : Potential or list of Potential instances, optional
            Gravitational potential to use for analytical calculation. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'spherical'}, optional
            Type of actionAngle module to use when analytic=True. Default is 'staeckel'.

        Returns
        -------
        float or numpy.ndarray [\*input_shape]
            Eccentricity of the orbit.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-25 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the apocenter radius, either numerically from the numerical orbit integration or using analytical means.

        Parameters
        ----------
        analytic : bool, optional
            If True, compute this analytically. Default is False.
        pot : Potential or list of Potential instances, optional
            Gravity potential to use for analytical calculation. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'spherical'}, optional
            Type of actionAngle module to use when analytic=True. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Apocenter radius of the orbit.

        Notes
        -----
        - 2019-02-25 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the pericenter radius, either numerically from the numerical orbit integration or using analytical means.

        Parameters
        ----------
        analytic : bool, optional
            If True, compute this analytically. Default is False.
        pot : Potential or list of Potential instances, optional
            Gravity potential to use for analytical calculation. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'spherical'}, optional
            Type of actionAngle module to use when analytic=True. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Pericenter radius of the orbit.

        Notes
        -----
        - 2019-02-25 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the guiding-center radius (the radius of a circular orbit with the same angular momentum).

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Guiding-center radius of the orbit.

        Notes
        -----
        - 2019-03-02 - Written as thin wrapper around Potential.rl - Bovy (UofT)

        See Also
        --------
        galpy.potential.Potential.rl


r"""
        Calculate the radius of a circular orbit with the same energy.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the radius. Default is the initial time.
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Radius of a circular orbit with the same energy.

        Notes
        -----
        - 2022-04-07 - Written as thin wrapper around Potential.rE - Bovy (UofT)


r"""
        Calculate the angular momentum of a circular orbit with the same energy.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the radius. Default is the initial time.
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Angular momentum of a circular orbit with the same energy.

        Notes
        -----
        - 2022-04-07 - Written - Bovy (UofT)


r"""
        Calculate the maximum vertical height, either numerically from the numerical orbit integration or using analytical means.

        Parameters
        ----------
        analytic : bool, optional
            Compute this analytically. Default is False.
        pot : Potential or list of Potential instances, optional
            Gravitational potential for the analytical calculation. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'spherical'}, optional
            Type of actionAngle module to use for 3D orbits when analytic=True. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Maximum vertical height.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-25 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the radial action.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Radial action.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-27 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the azimuthal action.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Azimuthal action.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-26 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the vertical action.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Vertical action.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-27 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the radial angle.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Radial angle.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-27 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the azimuthal angle.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Azimuthal angle.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-27 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the vertical angle.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Vertical angle.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-27 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the radial period.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Radial period.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-27 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the azimuthal period.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Azimuthal period.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-27 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the ratio between the radial and azimuthal period Tr/Tphi*pi.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        +actionAngle module setup kwargs

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Ratio between the radial and azimuthal period Tr/Tphi*pi

        Notes
        -----
        - 2019-02-27 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the vertical period.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale in km/s for velocities to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Vertical period.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-27 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the radial frequency.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Radial frequency.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-27 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the azimuthal frequency.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Azimuthal frequency.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-27 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Calculate the vertical frequency.

        Parameters
        ----------
        pot : Potential or list of Potential instances, optional
            Gravitational potential. Default is the gravitational field used for the orbit integration.
        type : {'staeckel', 'adiabatic', 'isochroneApprox', 'spherical'}, optional
            Type of actionAngle module to use. Default is 'staeckel'.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape]
            Vertical frequency.

        Notes
        -----
        - Keyword arguments also include the actionAngle module setup kwargs for the corresponding actionAngle modules
        - 2019-02-27 - Written - Bovy (UofT)

        See Also
        --------
        galpy.actionAngle.actionAngleStaeckel
        galpy.actionAngle.actionAngleAdiabatic
        galpy.actionAngle.actionAngleIsochroneApprox
        galpy.actionAngle.actionAngleSpherical


r"""
        Return the times at which the orbit is sampled.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the time (for consistency reasons). Default is to return the list of times at which the orbit is sampled.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Times at which the orbit is sampled.

        Notes
        -----
        - 2019-02-28 - Written - Bovy (UofT)


r"""
        Return cylindrical radius at time t.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the radius. Default is the initial time.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Cylindrical radius.

        Notes
        -----
        - 2019-02-01 - Written - Bovy (UofT)


r"""
        Return spherical radius at time t.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the radius. Default is the initial time.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Spherical radius.

        Notes
        -----
        - 2019-02-20: Written by Bovy (UofT).


r"""
        Return radial velocity at time t.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the radial velocity. Default is the initial time.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Radial velocity.

        Notes
        -----
        - 2019-02-20 - Written - Bovy (UofT)


r"""
        Return rotational velocity at time t.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the rotational velocity. Default is the initial time.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Rotational velocity.

        Notes
        -----
        - 2019-02-20 - Written by Bovy (UofT).


r"""
        Return vertical height.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the vertical height. Default is the initial time.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Vertical height.

        Notes
        -----
        - 2019-02-20: Written by Bovy (UofT).


r"""
        Return vertical velocity.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the vertical velocity. Default is the initial time.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Vertical velocity.

        Notes
        -----
        - 2019-02-20 - Written - Bovy (UofT)


r"""
        Return azimuth.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the azimuth. Default is the initial time.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Azimuth in [-pi,pi].

        Notes
        -----
        - 2019-02-20: Written by Bovy (UofT).


r"""
        Return x.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the x-coordinate. Default is the initial time.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            x-coordinate.

        Notes
        -----
        - 2019-02-20 - Written - Bovy (UofT)


r"""
        Return y.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the y-coordinate. Default is the initial time.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            y-coordinate.

        Notes
        -----
        - 2019-02-20 - Written - Bovy (UofT)


r"""
        Return x velocity at time t.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the x-velocity. Default is the initial time.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            x-velocity.

        Notes
        -----
        - 2019-02-20: Written by Bovy (UofT).


r"""
        Return y velocity at time t.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the y-velocity. Default is the initial time.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            y-velocity.

        Notes
        -----
        - 2019-02-20 - Written - Bovy (UofT)


r"""
        Return angular velocity.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the angular velocity. Default is the initial time.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Angular velocity.

        Notes
        -----
        - 2019-02-20 - Written - Bovy (UofT)


r"""
        Return spherical radial velocity. For < 3 dimensions returns vR.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the radial velocity. Default is the initial time.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Radial velocity.

        Notes
        -----
        - 2020-07-01: Written by James Lane (UofT).


r"""
        Return spherical polar velocity.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the theta velocity. Default is the initial time.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Spherical polar velocity.

        Notes
        -----
        - 2020-07-01: Written by James Lane (UofT).


r"""
        Return spherical polar angle.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the angle. Default is the initial time.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Spherical polar angle.

        Notes
        -----
        - 2020-07-01 - Written - James Lane (UofT)


r"""
        Return the right ascension.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the right ascension. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position of observer (in kpc, arranged as [X,Y,Z]; default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Right ascension.

        Notes
        -----
        - 2019-02-21: Written by Bovy (UofT).


r"""
        Return the declination.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the declination. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position of observer (in kpc, arranged as [X,Y,Z]; default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Declination.

        Notes
        -----
        - 2019-02-21: Written by Bovy (UofT).


r"""
        Return Galactic longitude.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the Galactic longitude. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position of observer (in kpc, arranged as [X,Y,Z]; default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Galactic longitude.

        Notes
        -----
        - 2019-02-21 - Written - Bovy (UofT)


r"""
        Return Galactic latitude.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the Galactic latitude. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position of observer (in kpc, arranged as [X,Y,Z]; default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Galactic latitude.

        Notes
        -----
        - 2019-02-21 - Written - Bovy (UofT)


r"""
        Return distance from the observer in kpc.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the distance. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position of observer (in kpc, arranged as [X,Y,Z]; default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Distance in kpc.

        Notes
        -----
        - 2019-02-21: Written by Bovy (UofT).


r"""
        Return proper motion in right ascension (in mas/yr).

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the proper motion. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer (in kpc and km/s, arranged as [X,Y,Z,vx,vy,vz]; default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Proper motion in right ascension in mas/yr.

        Notes
        -----
        - 2019-02-21 - Written - Bovy (UofT)


r"""
        Return proper motion in declination (in mas/yr).

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the proper motion. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer (in kpc and km/s, arranged as [X,Y,Z,vx,vy,vz]; default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Proper motion in declination in mas/yr.

        Notes
        -----
        - 2019-02-21 - Written - Bovy (UofT)


r"""
        Return proper motion in Galactic longitude (in mas/yr).

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the proper motion. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer (in kpc and km/s, arranged as [X,Y,Z,vx,vy,vz]; default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Proper motion in Galactic longitude in mas/yr.

        Notes
        -----
        - 2019-02-21 - Written - Bovy (UofT)


r"""
        Return proper motion in Galactic latitude (in mas/yr).

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the proper motion. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer (in kpc and km/s, arranged as [X,Y,Z,vx,vy,vz]; default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Proper motion in Galactic latitude in mas/yr.

        Notes
        -----
        This method returns the proper motion in Galactic latitude (in mas/yr).

        - 2019-02-21 - Written - Bovy (UofT)


r"""
        Return the line-of-sight velocity (in km/s).

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the line-of-sight velocity. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer (in kpc and km/s, arranged as [X,Y,Z,vx,vy,vz]; default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            Line-of-sight velocity in km/s.

        Notes
        -----
        - 2019-02-21 - Written - Bovy (UofT)


r"""
        Return velocity in right ascension (km/s).

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get vra. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer in the Galactocentric frame (in kpc and km/s) (default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        numpy.ndarray or Quantity [\*input_shape]
            v_ra(t) in km/s.

        Notes
        -----
        - 2019-02-28 - Written - Bovy (UofT)


r"""
        Return velocity in declination (km/s).

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get vdec. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer in the Galactocentric frame (in kpc and km/s) (default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        numpy.ndarray or Quantity [\*input_shape]
            v_dec(t) in km/s.

        Notes
        -----
        - 2019-02-28 - Written - Bovy (UofT)


r"""
        Return the velocity in Galactic longitude (km/s).

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get vll. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer in the Galactocentric frame (in kpc and km/s) (default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        numpy.ndarray or Quantity [\*input_shape]
            v_l(t) in km/s.

        Notes
        -----
        - 2019-02-28 - Written - Bovy (UofT)


r"""
        Return velocity in Galactic latitude (km/s).

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get vbb. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer in the Galactocentric frame (in kpc and km/s) (default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        numpy.ndarray or Quantity [\*input_shape]
            v_b(t) in km/s.

        Notes
        -----
        - Written on 2019-02-28 by Bovy (UofT)


r"""
        Return Heliocentric Galactic rectangular x-coordinate (aka "X").

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get X. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer in the Galactocentric frame (in kpc and km/s) (default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            helioX(t) in kpc.

        Notes
        -----
        - 2019-02-21 - Written - Bovy (UofT)


r"""
        Return Heliocentric Galactic rectangular y-coordinate (aka "Y").

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get Y. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer in the Galactocentric frame (in kpc and km/s) (default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            helioY(t) in kpc.

        Notes
        -----
        - 2019-02-21 - Written - Bovy (UofT)


r"""
        Return Heliocentric Galactic rectangular z-coordinate (aka "Z").

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get Z. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer in the Galactocentric frame (in kpc and km/s) (default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            helioZ(t) in kpc.

        Notes
        -----
        - Written on 2019-02-21 by Bovy (UofT)


r"""
        Return Heliocentric Galactic rectangular x-velocity (aka "U").

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get U. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer in the Galactocentric frame (in kpc and km/s) (default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            U(t) in km/s.

        Notes
        -----
        - 2019-02-21: Written by Bovy (UofT)


r"""
        Return Heliocentric Galactic rectangular y-velocity (aka "V").

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get V. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer in the Galactocentric frame (in kpc and km/s) (default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            V(t) in km/s.

        Notes
        -----
        - 2019-02-21: Written.


r"""
        Return Heliocentric Galactic rectangular z-velocity (aka "W").

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get W. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer in the Galactocentric frame (in kpc and km/s) (default=object-wide default) OR Orbit object that corresponds to the orbit of the observer. Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        float, numpy.ndarray or Quantity [\*input_shape,nt]
            W(t) in km/s.

        Notes
        -----
        - Written by Bovy (UofT) on 2019-02-21.


r"""
        Return the positions and velocities as an astropy SkyCoord.

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity, optional
            Time at which to get the position. Default is the initial time.
        obs : numpy.ndarray, Quantity or Orbit, optional
            Position and velocity of observer in the Galactocentric frame (in kpc and km/s; arranged as [x,y,z,vx,vy,vz]) (default=object-wide default) OR Orbit object that corresponds to the orbit of the observer.
            Note that when Y is non-zero, the coordinate system is rotated around z such that Y'=0.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        quantity : bool, optional
            If True, return an Astropy Quantity object. Default from configuration file.

        Returns
        -------
        SkyCoord [\*input_shape,nt]
            SkyCoord(t).

        Notes
        -----
        - 2019-02-21: Written - Bovy (UofT)


        Calculate the surface of section of the orbit.

        Parameters
        ----------
        pot : Potential, DissipativeForce, or list of such instances
            Gravitational field to integrate the orbit in.
        ncross : int, optional
            Number of times to cross the surface. Default is 500.
        surface : str, optional
            Surface to punch through. This has no effect in 3D, where the surface is always z=0, but in 2D it can be 'x' or 'y' for x=0 or y=0. Default is None.

        Other Parameters
        ----------------
        t0 : float or Quantity, optional
            Time of the initial condition. Default is 0.
        method : {'odeint', 'dop853_c', 'dop853', 'rk4_c', 'rk6_c', 'dop54_c'}, optional
            Integration method. Default is 'dop853_c'. See Notes for more information.
        skip : int, optional
            For non-adaptive integrators, the number of basic steps to take between crossings (these are further refined in the code, but only up to a maximum refinement, so you can use skip to get finer integration in cases where more accuracy is needed). Default is 100.
        progressbar : bool, optional
            If True, display a tqdm progress bar when integrating multiple orbits (requires tqdm to be installed!). Default is True.
        numcores : int, optional
            Number of cores to use for Python-based multiprocessing (pure Python or using force_map=True). Default is OMP_NUM_THREADS.
        force_map : bool, optional
            If True, force use of Python-based multiprocessing (not recommended). Default is False.

        Returns
        -------
        tuple
            (R,vR) for 3D orbits, (y,vy) for 2D orbits when surface=='x', (x,vx) for 2D orbits when surface=='y'.

        Notes
        -----
        - Possible integration methods are:

          - 'odeint' for scipy's odeint
          -  'rk4_c' for a 4th-order Runge-Kutta integrator in C
          -  'rk6_c' for a 6-th order Runge-Kutta integrator in C
          -  'dopr54_c' for a 5-4 Dormand-Prince integrator in C
          -  'dop853' for a 8-5-3 Dormand-Prince integrator in Python
          -  'dop853_c' for a 8-5-3 Dormand-Prince integrator in C

        - 2023-03-16 - Written - Bovy (UofT)


        Return the orbits vector at time t

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity
            Desired time. Default is the initial time.

        Returns
        -------
        ndarray
            [R,vR,vT,z,vz(,phi)] or [R,vR,vT(,phi)] depending on the orbit; shape = [phasedim,nt,norb]

        Notes
        -----
        - 2019-02-01 - Started - Bovy (UofT)
        - 2019-02-18 - Written interpolation part - Bovy (UofT)


        Convert 3D orbits into 2D orbits.

        Returns
        -------
        Orbit
            Planar Orbit instance.

        Notes
        -----
        - 2019-03-02 - Written - Bovy (UofT)


        Convert 3D orbits into 1D orbits (z phase space).

        Returns
        -------
        Orbit
            Linear Orbit instance.

        Notes
        -----
        - 2019-03-02 - Written - Bovy (UofT)


Internal function to parse a quantity to be plotted based on input data


        Plot a previously calculated orbit.

        Parameters
        ----------
        d1 : str or callable, optional
            First dimension to plot. Can be a string ('x', 'y', 'R', 'vR', 'vT', 'z', 'vz', ...), an expression like 'R*vR', or a user-defined function of time (e.g., lambda t: o.R(t) for R). Default is determined by the number of dimensions in the orbit.
        d2 : str or callable, optional
            Second dimension to plot. Same format as d1.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is the object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is the object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        *args : optional
            Additional arguments to pass to galpy.util.plot.plot.
        **kwargs : optional
            Additional keyword arguments to pass to galpy.util.plot.plot.

        Returns
        -------
        list
            A list of matplotlib.lines.Line2D objects representing the plotted data.

        Notes
        -----
        - 2010-07-26 - Written - Bovy (NYU)
        - 2010-09-22 - Adapted to more general framework - Bovy (NYU)
        - 2013-11-29 - Added ra,dec kwargs and other derived quantities - Bovy (IAS)
        - 2014-06-11 - Support for plotting in physical coordinates - Bovy (IAS)
        - 2017-11-28 - Allow arbitrary functions of time to be plotted - Bovy (UofT)
        - 2019-04-13 - Edited for multiple Orbits - Bovy (UofT)


        Plot 3D aspects of an Orbit.

        Parameters
        ----------
        d1 : str or callable
            First dimension to plot ('x', 'y', 'R', 'vR', 'vT', 'z', 'vz', ...); can also be an expression, like 'R*vR', or a user-defined function of time (e.g., lambda t: o.R(t) for R).
        d2 : str or callable
            Second dimension to plot. Same format as d1.
        d3 : str or callable
            Third dimension to plot. Same format as d1.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is the object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is the object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.
        *args : optional
            Additional arguments to pass to galpy.util.plot.plot3d.
        **kwargs : optional
            Additional keyword arguments to pass to galpy.util.plot.plot3d.

        Returns
        -------
        list
            A list of matplotlib.lines.Line3D objects representing the plotted data.

        Notes
        -----
        - 2010-07-26 - Written - Bovy (NYU)
        - 2010-09-22 - Adapted to more general framework - Bovy (NYU)
        - 2010-01-08 - Adapted to 3D - Bovy (NYU)
        - 2013-11-29 - Added ra,dec kwargs and other derived quantities - Bovy (IAS)
        - 2014-06-11 - Support for plotting in physical coordinates - Bovy (IAS)
        - 2017-11-28 - Allow arbitrary functions of time to be plotted - Bovy (UofT)
        - 2019-04-13 - Adapted for multiple orbits - Bovy (UofT)


        Calculate and plot a surface of section of the orbit.

        Parameters
        ----------
        pot : Potential, DissipativeForce, or list of such instances
            Gravitational field to integrate the orbit in.
        ncross : int, optional
            Number of times to cross the surface. The default is 500.
        surface : str, optional
            Surface to punch through (this has no effect in 3D, where the surface is always z=0, but in 2D it can be 'x' or 'y' for x=0 or y=0). The default is None.
        t0 : float or Quantity, optional
            Time of the initial condition. The default is 0.0.
        method : {'odeint', 'dop853_c', 'dop853', 'dop54_c', 'rk4_c', 'rk6_c'}, optional
            Method to integrate the orbit. The default is 'dop853_c'.
        skip : int, optional
            For non-adaptive integrators, the number of basic steps to take between crossings (these are further refined in the code, but only up to a maximum refinement, so you can use skip to get finer integration in cases where more accuracy is needed). The default is 100.
        progressbar : bool, optional
            If True, display a tqdm progress bar when integrating multiple orbits (requires tqdm to be installed!). The default is True.
        *args : optional
            Additional arguments to pass to galpy.util.plot.plot.
        **kwargs : optional
            Additional keyword arguments to pass to galpy.util.plot.plot.

        Notes
        -----
        - 2023-03-16 - Written - Bovy (UofT)


Shared code between plotSOS and plotBruteSOS


        Animate a previously calculated orbit.

        Parameters
        ----------
        d1 : str or callable or list
            First dimension to plot ('x', 'y', 'R', 'vR', 'vT', 'z', 'vz', ...).
            Can be a list with up to three entries for three subplots. Each entry
            can also be an expression like 'R*vR' or a  user-defined function of time
            (e.g., lambda t: o.R(t) for R).
        d2 : str or callable or list
            Second dimension to plot. Same format as d1.
        width : int, optional
            Width of output div in pixels. Default is 600.
        height : int, optional
            Height of output div in pixels. Default is 400.
        xlabel : str or list, optional
            Label for the first dimension (or list of labels if d1 is a list).
            Should only have to be specified when using a function as d1 and can
            then specify as, e.g., [None,'YOUR LABEL',None] if d1 is a list of
            three xs and the first and last are standard entries).
        ylabel : str or list, optional
            Label for the second dimension. Same format as xlabel.
        json_filename : str, optional
            If set, save the data necessary for the figure in this filename (e.g.,
            json_filename= 'orbit_data/orbit.json'). This path is also used in the
            output HTML, so needs to be accessible.
        staticPlot : bool, optional
            If True, create a static plot that doesn't allow zooming, panning, etc.
            Default is False.
        ro : float or Quantity, optional
            Physical scale in kpc for distances to use to convert. Default is the object-wide default.
        vo : float or Quantity, optional
            Physical scale for velocities in km/s to use to convert. Default is the object-wide default.
        use_physical : bool, optional
            Use to override object-wide default for using a physical scale for output.

        Returns
        -------
        IPython.display.HTML
            Object with code to animate the orbit. Can be directly shown in
            Jupyter notebook or embedded in HTML pages. Get a text version of the
            HTML using the _repr_html_() function.

        Notes
        -----
        - 2017-09-17 - Written - Bovy (UofT)
        - 2019-03-11 - Adapted for multiple orbits - Bovy (UofT)