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

        """

        # Evaluate the latitude

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

        # Get the longitude and apex height

        alon = qlon

        h_apex = self.get_apex(qlat, height)

        if h_apex < self.refh:

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

                # Allow for values that are close

                h_apex = self.refh

            else:

                estr = ''.join(['apex height ({:.3g}) is < '.format(h_apex),

                                'reference height ({:.3g})'.format(self.refh),

                                ' for qlat {:.3g}'.format(qlat)])

                raise ApexHeightError(estr)

        # Convert the latitude

        sqlat = np.sign(qlat) if qlat != 0 else 1

        alat = sqlat * np.degrees(np.arccos(np.sqrt((self.RE + self.refh)

                                                    / (self.RE + h_apex))))

        return alat, alon

    def _map_EV_to_height(self, alat, alon, height, newheight, data, ev_flag):

        """Maps electric field related values to a desired 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):

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