aburrell / apexpy

        return qlat, qlon

    def _qd2apex_nonvectorized(self, qlat, qlon, height):

        """Converts quasi-dipole to modified apex coordinates.

        Parameters

        ----------

        qlat : float

            Quasi-dipole latitude

        qlon : float

            Quasi-dipole longitude

        height : float

            Altitude in km

        Returns

        -------

        alat : float

            Modified apex latitude

        alon : float

            Modified apex longitude

        Raises

        ------

        ApexHeightError

            if apex height < reference height

        """

    # -------------------------

    # Define the hidden methods

    def _apex2qd_nonvectorized(self, alat, alon, height):

        """Convert from apex to quasi-dipole (not-vectorised)

        Parameters

        -----------

        alat : (float)

            Apex latitude in degrees

        alon : (float)

            Apex longitude in degrees

        height : (float)

            Height in km

        Returns

        ---------

        qlat : (float)

            Quasi-dipole latitude in degrees

        qlon : (float)

            Quasi-diplole longitude in degrees

        """

        # Evaluate the latitude

        alat = helpers.checklat(alat, name='alat')

        # Convert modified apex to quasi-dipole, longitude is the same

        qlon = alon

        # Get the apex height

        h_apex = self.get_apex(alat)

        if h_apex < height:

            if np.isclose(h_apex, height, rtol=0, atol=1e-5):

                # Allow for values that are close

                h_apex = height

            else:

                estr = ''.join(['height {:.3g} is > '.format(np.max(height)),

                                'apex height {:.3g} for alat {:.3g}'.format(

                                    h_apex, alat)])

                raise ApexHeightError(estr)

        # Convert the latitude

        salat = np.sign(alat) if alat != 0 else 1

        qlat = salat * np.degrees(np.arccos(np.sqrt((self.RE + height) /

                                                    (self.RE + h_apex))))

        return qlat, qlon

    def _qd2apex_nonvectorized(self, qlat, qlon, height):