aburrell / apexpy

        # if array is returned, dtype is object, so convert to float

        return np.float64(glat), np.float64(glon), np.float64(error)

    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

        """

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

        # convert modified apex to quasi-dipole:

        qlon = alon

        # apex height

        hA = self.get_apex(alat)

        if hA < height:

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

                # allow for values that are close

                hA = height

            else:

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

                estr += '{:.3g} for alat {:.3g}'.format(hA, alat)

                raise ApexHeightError(estr)

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

                                                            (self.RE + hA))))

        return qlat, qlon

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

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

        # if array is returned, the dtype is object, so convert to float

        return np.float64(qlat), np.float64(qlon)

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

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

        alon = qlon

        hA = self.get_apex(qlat, height) # apex height

        if hA < self.refh:

            if np.isclose(hA, self.refh, rtol=0, atol=1e-5):

                # allow for values that are close

                hA = self.refh

            else:

                estr = 'apex height ({:.3g}) is < reference height '.format(hA)

                estr += '({:.3g}) for qlat {:.3g}'.format(self.refh, qlat)

                raise ApexHeightError(estr)

        alat = np.sign(qlat) * np.degrees(np.arccos(np.sqrt((self.RE +

                                                             self.refh) /

                                                            (self.RE + hA))))

        return alat, alon

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

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