File indexing completed on 2024-04-21 03:44:44

 /*
     SPDX-FileCopyrightText: 2001-2005 Jason Harris <jharris@30doradus.org>
     SPDX-FileCopyrightText: 2004-2005 Pablo de Vicente <p.devicente@wanadoo.es>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include "cachingdms.h"
 #include "kstarsdatetime.h"
 
 #include <QList>
 #ifndef KSTARS_LITE
 #include <QDBusArgument>
 #endif
 
 //#define PROFILE_COORDINATE_CONVERSION
 
 class KSNumbers;
 class KSSun;
 class GeoLocation;
 
 /**
  * @class SkyPoint
  *
  * The sky coordinates of a point in the sky.  The
  * coordinates are stored in both Equatorial (Right Ascension,
  * Declination) and Horizontal (Azimuth, Altitude) coordinate systems.
  * Provides set/get functions for each coordinate angle, and functions
  * to convert between the Equatorial and Horizon coordinate systems.
  *
  * Because the coordinate values change slowly over time (due to
  * precession, nutation), the "catalog coordinates" are stored
  * (RA0, Dec0), which were the true coordinates on Jan 1, 2000.
  * The true coordinates (RA, Dec) at any other epoch can be found
  * from the catalog coordinates using updateCoords().
  * @short Stores dms coordinates for a point in the sky.
  * for converting between coordinate systems.
  *
  * @author Jason Harris
  * @version 1.0
  */
 class SkyPoint
 {
     public:
         /**
          * Default constructor: Sets RA, Dec and RA0, Dec0 according
          * to arguments.  Does not set Altitude or Azimuth.
          *
          * @param r Right Ascension
          * @param d Declination
          */
         SkyPoint(const dms &r, const dms &d) : RA0(r), Dec0(d), RA(r), Dec(d), lastPrecessJD(J2000) {}
 
         SkyPoint(const CachingDms &r, const CachingDms &d) : RA0(r), Dec0(d), RA(r), Dec(d), lastPrecessJD(J2000) {}
 
         /**
          * Alternate constructor using double arguments, for convenience.
          * It behaves essentially like the default constructor.
          *
          * @param r Right Ascension, expressed as a double
          * @param d Declination, expressed as a double
          * @note This also sets RA0 and Dec0
          */
         //FIXME: this (*15.0) thing is somewhat hacky.
         explicit SkyPoint(double r, double d) : RA0(r * 15.0), Dec0(d), RA(r * 15.0), Dec(d), lastPrecessJD(J2000) {}
 
         /** @short Default constructor. Sets nonsense values for RA, Dec etc */
         SkyPoint();
 
         virtual ~SkyPoint() = default;
 
         ////
         //// 1.  Setting Coordinates
         //// =======================
 
         /**
          * @short Sets RA, Dec and RA0, Dec0 according to arguments.
          * Does not set Altitude or Azimuth.
          *
          * @param r Right Ascension
          * @param d Declination
          * @note This function also sets RA0 and Dec0 to the same values, so call at your own peril!
          * @note FIXME: This method must be removed, or an epoch argument must be added.
          */
         void set(const dms &r, const dms &d);
 
         /**
          * Sets RA0, the catalog Right Ascension.
          *
          * @param r catalog Right Ascension.
          */
         inline void setRA0(dms r)
         {
             RA0 = r;
         }
         inline void setRA0(CachingDms r)
         {
             RA0 = r;
         }
 
         /**
          * Overloaded member function, provided for convenience.
          * It behaves essentially like the above function.
          *
          * @param r Right Ascension, expressed as a double.
          */
         inline void setRA0(double r)
         {
             RA0.setH(r);
         }
 
         /**
          * Sets Dec0, the catalog Declination.
          *
          * @param d catalog Declination.
          */
         inline void setDec0(dms d)
         {
             Dec0 = d;
         }
         inline void setDec0(const CachingDms &d)
         {
             Dec0 = d;
         }
 
         /**
          * Overloaded member function, provided for convenience.
          * It behaves essentially like the above function.
          *
          * @param d Declination, expressed as a double.
          */
         inline void setDec0(double d)
         {
             Dec0.setD(d);
         }
 
         /**
          * Sets RA, the current Right Ascension.
          *
          * @param r Right Ascension.
          */
         inline void setRA(dms &r)
         {
             RA = r;
         }
         inline void setRA(const CachingDms &r)
         {
             RA = r;
         }
 
         /**
          * Overloaded member function, provided for convenience.
          * It behaves essentially like the above function.
          *
          * @param r Right Ascension, expressed as a double.
          */
         inline void setRA(double r)
         {
             RA.setH(r);
         }
 
         /**
          * Sets Dec, the current Declination
          *
          * @param d Declination.
          */
         inline void setDec(dms d)
         {
             Dec = d;
         }
         inline void setDec(const CachingDms &d)
         {
             Dec = d;
         }
 
         /**
          * Overloaded member function, provided for convenience.
          * It behaves essentially like the above function.
          *
          * @param d Declination, expressed as a double.
          */
         inline void setDec(double d)
         {
             Dec.setD(d);
         }
 
         /**
          * Sets Alt, the Altitude.
          *
          * @param alt Altitude.
          */
         inline void setAlt(dms alt)
         {
             Alt = alt;
         }
 
         /**
          * Sets the apparent altitude, checking whether refraction corrections are enabled
          *
          * @param alt_apparent Apparent altitude (subject to Options::useRefraction())
          */
         void setAltRefracted(dms alt_apparent);
 
         /**
          * Overloaded member function, provided for convenience.
          * It behaves essentially like the above function.
          *
          * @param alt_apparent Apparent altitude (subject to Options::useRefraction())
          */
         void setAltRefracted(double alt_apparent);
 
         /**
          * Overloaded member function, provided for convenience.
          * It behaves essentially like the above function.
          *
          * @param alt Altitude, expressed as a double.
          */
         inline void setAlt(double alt)
         {
             Alt.setD(alt);
         }
 
         /**
          * Sets Az, the Azimuth.
          *
          * @param az Azimuth.
          */
         inline void setAz(dms az)
         {
             Az = az;
         }
 
         /**
          * Overloaded member function, provided for convenience.
          * It behaves essentially like the above function.
          *
          * @param az Azimuth, expressed as a double.
          */
         inline void setAz(double az)
         {
             Az.setD(az);
         }
 
         ////
         //// 2. Returning coordinates.
         //// =========================
 
         /** @return a pointer to the catalog Right Ascension. */
         inline const CachingDms &ra0() const
         {
             return RA0;
         }
 
         /** @return a pointer to the catalog Declination. */
         inline const CachingDms &dec0() const
         {
             return Dec0;
         }
 
         /** @returns a pointer to the current Right Ascension. */
         inline const CachingDms &ra() const
         {
             return RA;
         }
 
         /** @return a pointer to the current Declination. */
         inline const CachingDms &dec() const
         {
             return Dec;
         }
 
         /** @return a pointer to the current Azimuth. */
         inline const dms &az() const
         {
             return Az;
         }
 
         /** @return a pointer to the current Altitude. */
         inline const dms &alt() const
         {
             return Alt;
         }
 
         /**
          * @return refracted altitude. This function uses
          * Options::useRefraction to determine whether refraction
          * correction should be applied
          */
         dms altRefracted() const;
 
         /** @return the JD for the precessed coordinates */
         inline double getLastPrecessJD() const
         {
             return lastPrecessJD;
         }
 
         /**
          * @return the airmass of the point. Convenience method.
          * @note Question: is it better to use alt or refracted alt? Minor difference, probably doesn't matter.
          */
         inline double airmass() const
         {
             return 1. / sin(alt().radians());
         }
 
         ////
         //// 3. Coordinate conversions.
         //// ==========================
 
         /**
          * Determine the (Altitude, Azimuth) coordinates of the
          * SkyPoint from its (RA, Dec) coordinates, given the local
          * sidereal time and the observer's latitude.
          * @param LST pointer to the local sidereal time
          * @param lat pointer to the geographic latitude
          */
         void EquatorialToHorizontal(const CachingDms *LST, const CachingDms *lat);
 
         // Deprecated method provided for compatibility
         void EquatorialToHorizontal(const dms *LST, const dms *lat);
 
         /**
          * Determine the (RA, Dec) coordinates of the
          * SkyPoint from its (Altitude, Azimuth) coordinates, given the local
          * sidereal time and the observer's latitude.
          *
          * @param LST pointer to the local sidereal time
          * @param lat pointer to the geographic latitude
          */
         void HorizontalToEquatorial(const dms *LST, const dms *lat);
 
         /**
          * Determine the Ecliptic coordinates of the SkyPoint, given the Julian Date.
          * The ecliptic coordinates are returned as reference arguments (since
          * they are not stored internally)
          */
         void findEcliptic(const CachingDms *Obliquity, dms &EcLong, dms &EcLat);
 
         /**
          * Set the current (RA, Dec) coordinates of the
          * SkyPoint, given pointers to its Ecliptic (Long, Lat) coordinates, and
          * to the current obliquity angle (the angle between the equator and ecliptic).
          */
         void setFromEcliptic(const CachingDms *Obliquity, const dms &EcLong, const dms &EcLat);
 
         /**
          * Computes galactic coordinates from equatorial coordinates referred to
          * epoch 1950. RA and Dec are, therefore assumed to be B1950 coordinates.
          */
         void Equatorial1950ToGalactic(dms &galLong, dms &galLat);
 
         /**
          * Computes equatorial coordinates referred to 1950 from galactic ones referred to
          * epoch B1950. RA and Dec are, therefore assumed to be B1950 coordinates.
          */
         void GalacticToEquatorial1950(const dms *galLong, const dms *galLat);
 
         ////
         //// 4. Coordinate update/corrections.
         //// =================================
 
         /**
          * Determine the current coordinates (RA, Dec) from the catalog
          * coordinates (RA0, Dec0), accounting for both precession and nutation.
          * @param num pointer to KSNumbers object containing current values of time-dependent variables.
          * @param includePlanets does nothing in this implementation (see KSPlanetBase::updateCoords()).
          * @param lat does nothing in this implementation (see KSPlanetBase::updateCoords()).
          * @param LST does nothing in this implementation (see KSPlanetBase::updateCoords()).
          * @param forceRecompute reapplies precession, nutation and aberration even if the time passed
          * since the last computation is not significant.
          */
         virtual void updateCoords(const KSNumbers *num, bool includePlanets = true, const CachingDms *lat = nullptr,
                                   const CachingDms *LST = nullptr, bool forceRecompute = false);
 
         /**
          * @brief updateCoordsNow Shortcut for updateCoords( const KSNumbers *num, false, nullptr, nullptr, true)
          *
          * @param num pointer to KSNumbers object containing current values of time-dependent variables.
          */
         virtual void updateCoordsNow(const KSNumbers *num)
         {
             updateCoords(num, false, nullptr, nullptr, true);
         }
 
         /**
          * Computes the apparent coordinates for this SkyPoint for any epoch,
          * accounting for the effects of precession, nutation, and aberration.
          * Similar to updateCoords(), but the starting epoch need not be
          * J2000, and the target epoch need not be the present time.
          *
          * @param jd0 Julian Day which identifies the original epoch
          * @param jdf Julian Day which identifies the final epoch
          */
         void apparentCoord(long double jd0, long double jdf);
 
         /**
          * Computes the J2000.0 catalogue coordinates for this SkyPoint using the epoch
          * removing aberration, nutation and precession
          * Catalogue coordinates are in Ra0, Dec0 as well as Ra, Dec and lastPrecessJD is set to J2000.0
          *
          * @FIXME We do not undo nutation and aberration
          * @brief catalogueCoord converts observed to J2000 using epoch jdf
          * @param jdf Julian Day which identifies the current epoch
          * @return SpyPoint containing J2000 coordinates
          */
 
         SkyPoint catalogueCoord(long double jdf);
 
 
         /**
          * Apply the effects of nutation to this SkyPoint.
          *
          * @param num pointer to KSNumbers object containing current values of
          * time-dependent variables.
          * @param reverse bool, if true the nutation is removed
          */
         void nutate(const KSNumbers *num, const bool reverse = false);
 
         /**
          * @short Check if this sky point is close enough to the sun for
          * gravitational lensing to be significant
          */
         bool checkBendLight();
 
         /**
          * Correct for the effect of "bending" of light around the sun for
          * positions near the sun.
          *
          * General Relativity tells us that a photon with an impact
          * parameter b is deflected through an angle 1.75" (Rs / b) where
          * Rs is the solar radius.
          *
          * @return: true if the light was bent, false otherwise
          */
         bool bendlight();
 
         /**
          * @short Obtain a Skypoint with RA0 and Dec0 set from the RA, Dec
          * of this skypoint. Also set the RA0, Dec0 of this SkyPoint if not
          * set already and the target epoch is J2000.
          */
         SkyPoint deprecess(const KSNumbers *num, long double epoch = J2000);
 
         /**
          * Determine the effects of aberration for this SkyPoint.
          *
          * @param num pointer to KSNumbers object containing current values of
          * time-dependent variables.
          * @param reverse bool, if true the aberration is removed.
          */
         void aberrate(const KSNumbers *num, bool reverse = false);
 
         /**
          * General case of precession. It precess from an original epoch to a
          * final epoch. In this case RA0, and Dec0 from SkyPoint object represent
          * the coordinates for the original epoch and not for J2000, as usual.
          *
          * @param jd0 Julian Day which identifies the original epoch
          * @param jdf Julian Day which identifies the final epoch
          */
         void precessFromAnyEpoch(long double jd0, long double jdf);
 
         /**
          * Determine the E-terms of aberration
          * In the past, the mean places of stars published in catalogs included
          * the contribution to the aberration due to the ellipticity of the orbit
          * of the Earth. These terms, known as E-terms were almost constant, and
          * in the newer catalogs (FK5) are not included. Therefore to convert from
          * FK4 to FK5 one has to compute these E-terms.
          */
         SkyPoint Eterms(void);
 
         /**
          * Exact precession from Besselian epoch 1950 to epoch J2000. The
          * coordinates referred to the first epoch are in the
          * FK4 catalog, while the latter are in the Fk5 one.
          *
          * Reference: Smith, C. A.; Kaplan, G. H.; Hughes, J. A.; Seidelmann,
          * P. K.; Yallop, B. D.; Hohenkerk, C. Y.
          * Astronomical Journal, vol. 97, Jan. 1989, p. 265-279
          *
          * This transformation requires 4 steps:
          * - Correct E-terms
          * - Precess from B1950 to 1984, January 1st, 0h, using Newcomb expressions
          * - Add zero point correction in right ascension for 1984
          * - Precess from 1984, January 1st, 0h to J2000
          */
         void B1950ToJ2000(void);
 
         /**
          * Exact precession from epoch J2000 Besselian epoch 1950. The coordinates
          * referred to the first epoch are in the FK4 catalog, while the
          * latter are in the Fk5 one.
          *
          * Reference: Smith, C. A.; Kaplan, G. H.; Hughes, J. A.; Seidelmann,
          * P. K.; Yallop, B. D.; Hohenkerk, C. Y.
          * Astronomical Journal, vol. 97, Jan. 1989, p. 265-279
          *
          * This transformation requires 4 steps:
          * - Precess from J2000 to 1984, January 1st, 0h
          * - Add zero point correction in right ascension for 1984
          * - Precess from 1984, January 1st, 0h, to B1950 using Newcomb expressions
          * - Correct E-terms
          */
         void J2000ToB1950(void);
 
         /**
          * Coordinates in the FK4 catalog include the effect of aberration due
          * to the ellipticity of the orbit of the Earth. Coordinates in the FK5
          * catalog do not include these terms. In order to convert from B1950 (FK4)
          * to actual mean places one has to use this function.
          */
         void addEterms(void);
 
         /**
          * Coordinates in the FK4 catalog include the effect of aberration due
          * to the ellipticity of the orbit of the Earth. Coordinates in the FK5
          * catalog do not include these terms. In order to convert from
          * FK5 coordinates to B1950 (FK4) one has to use this function.
          */
         void subtractEterms(void);
 
         /**
          * Computes the angular distance between two SkyObjects. The algorithm
          * to compute this distance is:
          * cos(distance) = sin(d1)*sin(d2) + cos(d1)*cos(d2)*cos(a1-a2)
          * where a1,d1 are the coordinates of the first object and a2,d2 are
          * the coordinates of the second object.
          * However this algorithm is not accurate when the angular separation is small.
          * Meeus provides a different algorithm in page 111 which we implement here.
          *
          * @param sp SkyPoint to which distance is to be calculated
          * @param positionAngle if a non-null pointer is passed, the position angle [E of N]
          * in degrees from this SkyPoint to sp is computed and stored in the passed variable.
          * @return dms angle representing angular separation.
          **/
         dms angularDistanceTo(const SkyPoint *sp, double *const positionAngle = nullptr) const;
 
         /** @return returns true if _current_ epoch RA / Dec match */
         inline bool operator==(SkyPoint &p) const
         {
             return (ra() == p.ra() && dec() == p.dec());
         }
 
         /**
          * Computes the velocity of the Sun projected on the direction of the source.
          *
          * @param jd Epoch expressed as julian day to which the source coordinates refer to.
          * @return Radial velocity of the source referred to the barycenter of the solar system in km/s
          **/
         double vRSun(long double jd);
 
         /**
          * Computes the radial velocity of a source referred to the solar system barycenter
          * from the radial velocity referred to the
          * Local Standard of Rest, aka known as VLSR. To compute it we need the coordinates of the
          * source the VLSR and the epoch for the source coordinates.
          *
          * @param vlsr radial velocity of the source referred to the LSR in km/s
          * @param jd Epoch expressed as julian day to which the source coordinates refer to.
          * @return Radial velocity of the source referred to the barycenter of the solar system in km/s
          **/
         double vHeliocentric(double vlsr, long double jd);
 
         /**
          * Computes the radial velocity of a source referred to the Local Standard of Rest, also known as VLSR
          * from the radial velocity referred to the solar system barycenter
          *
          * @param vhelio radial velocity of the source referred to the LSR in km/s
          * @param jd Epoch expressed as julian day to which the source coordinates refer to.
          * @return Radial velocity of the source referred to the barycenter of the solar system in km/s
          **/
         double vHelioToVlsr(double vhelio, long double jd);
 
         /**
          * Computes the velocity of any object projected on the direction of the source.
          *
          * @param jd0 Julian day for which we compute the direction of the source
          * @return velocity of the Earth projected on the direction of the source kms-1
          */
         double vREarth(long double jd0);
 
         /**
          * Computes the radial velocity of a source referred to the center of the earth
          * from the radial velocity referred to the solar system barycenter
          *
          * @param vhelio radial velocity of the source referred to the barycenter of the
          *               solar system in km/s
          * @param jd     Epoch expressed as julian day to which the source coordinates refer to.
          * @return Radial velocity of the source referred to the center of the Earth in km/s
          **/
         double vGeocentric(double vhelio, long double jd);
 
         /**
          * Computes the radial velocity of a source referred to the solar system barycenter
          * from the velocity referred to the center of the earth
          *
          * @param vgeo   radial velocity of the source referred to the center of the Earth [km/s]
          * @param jd     Epoch expressed as julian day to which the source coordinates refer to.
          * @return Radial velocity of the source referred to the solar system barycenter in km/s
          **/
         double vGeoToVHelio(double vgeo, long double jd);
 
         /**
          * Computes the velocity of any object (observer's site) projected on the
          * direction of the source.
          *
          * @param vsite velocity of that object in cartesian coordinates
          * @return velocity of the object projected on the direction of the source kms-1
          */
         double vRSite(double vsite[3]);
 
         /**
          * Computes the radial velocity of a source referred to the observer site on the surface
          * of the earth from the geocentric velocity and the velocity of the site referred to the center
          * of the Earth.
          *
          * @param vgeo radial velocity of the source referred to the center of the earth in km/s
          * @param vsite Velocity at which the observer moves referred to the center of the earth.
          * @return Radial velocity of the source referred to the observer's site in km/s
          **/
         double vTopocentric(double vgeo, double vsite[3]);
 
         /**
          * Computes the radial velocity of a source referred to the center of the Earth from
          * the radial velocity referred to an observer site on the surface of the earth
          *
          * @param vtopo radial velocity of the source referred to the observer's site in km/s
          * @param vsite Velocity at which the observer moves referred to the center of the earth.
          * @return Radial velocity of the source referred the center of the earth in km/s
          **/
         double vTopoToVGeo(double vtopo, double vsite[3]);
 
         /**
          * Find the SkyPoint obtained by moving distance dist
          * (arcseconds) away from the givenSkyPoint
          *
          * @param dist Distance to move through in arcseconds
          * @param from The SkyPoint to move away from
          * @return a SkyPoint that is at the dist away from this SkyPoint in the direction away from
          */
         SkyPoint moveAway(const SkyPoint &from, double dist) const;
 
         /** @short Check if this point is circumpolar at the given geographic latitude */
         bool checkCircumpolar(const dms *gLat) const;
 
         /** Calculate refraction correction. Parameter and return value are in degrees */
         static double refractionCorr(double alt);
 
         /**
          * @short Apply refraction correction to altitude, depending on conditional
          *
          * @param alt altitude to be corrected, in degrees
          * @param conditional an optional boolean to decide whether to apply the correction or not
          * @note If conditional is false, this method returns its argument unmodified. This is a convenience feature as it is often needed to gate these corrections.
          * @return altitude after refraction correction (if applicable), in degrees
          */
         static double refract(const double alt, bool conditional = true);
 
         /**
          * @short Remove refraction correction, depending on conditional
          *
          * @param alt altitude from which refraction correction must be removed, in degrees
          * @param conditional an optional boolean to decide whether to undo the correction or not
          * @return altitude without refraction correction, in degrees
          * @note If conditional is false, this method returns its argument unmodified. This is a convenience feature as it is often needed to gate these corrections.
          */
         static double unrefract(const double alt, bool conditional = true);
 
         /**
          * @short Apply refraction correction to altitude. Overloaded method using
          * dms provided for convenience
          * @see SkyPoint::refract( const double alt )
          */
         static inline dms refract(const dms alt, bool conditional = true)
         {
             return dms(refract(alt.Degrees(), conditional));
         }
 
         /**
          * @short Remove refraction correction. Overloaded method using
          * dms provided for convenience
          * @see SkyPoint::unrefract( const double alt )
          */
         static inline dms unrefract(const dms alt, bool conditional = true)
         {
             return dms(unrefract(alt.Degrees(), conditional));
         }
 
         /**
          * @short Compute the altitude of a given skypoint hour hours from the given date/time
          *
          * @param p SkyPoint whose altitude is to be computed (const pointer, the method works on a clone)
          * @param dt Date/time that corresponds to 0 hour
          * @param geo GeoLocation object specifying the location
          * @param hour double specifying offset in hours from dt for which altitude is to be found
          * @return a dms containing (unrefracted?) altitude of the object at dt + hour hours at the given location
          *
          * @note This method is used in multiple places across KStars
          * @todo Fix code duplication in AltVsTime and KSAlmanac by using this method instead! FIXME.
          */
         static dms findAltitude(const SkyPoint *p, const KStarsDateTime &dt, const GeoLocation *geo, const double hour = 0);
 
         /**
          * @short returns a time-transformed SkyPoint. See SkyPoint::findAltitude() for details
          * @todo Fix this documentation.
          */
         static SkyPoint timeTransformed(const SkyPoint *p, const KStarsDateTime &dt, const GeoLocation *geo,
                                         const double hour = 0);
 
         /**
          * @short Critical height for atmospheric refraction
          * corrections. Below this, the height formula produces meaningless
          * results and the correction value is just interpolated.
          */
         static const double altCrit;
 
         /**
          * @short Return the object's altitude at the upper culmination for the given latitude
          *
          * @return the maximum altitude in degrees
          */
         double maxAlt(const dms &lat) const;
 
         /**
          * @short Return the object's altitude at the lower culmination for the given latitude
          *
          * @return the minimum altitude in degrees
          */
         double minAlt(const dms &lat) const;
 
         /**
          * @short Return the Parallactic Angle
          *
          * The parallactic angle is the angle between "up" and
          * "north". See Jean Meeus' "Astronomical Algorithms" second
          * edition, Chapter 14 for more details (especially Fig 4 on Pg
          * 99). The angle returned in this case, between a vector of
          * increasing altitude and a vector of increasing declination, is
          * measured in the clockwise sense as seen on the sky.
          *
          * @param LST Local Sidereal Time
          * @param lat Latitude
          *
          * @note EquatorialToHorizontal() need not be called before
          * invoking this, but it is wise to call updateCoords() to ensure
          * ra() and dec() refer to the right epoch.
          *
          * @return the parallactic angle in the clockwise sense
          */
         dms parallacticAngle(const CachingDms &LST, const CachingDms &lat);
 
 #ifdef PROFILE_COORDINATE_CONVERSION
         static double cpuTime_EqToHz;
         static long unsigned eqToHzCalls;
 #endif
         static bool implementationIsLibnova;
 
     protected:
         /**
          * Precess this SkyPoint's catalog coordinates to the epoch described by the
          * given KSNumbers object.
          *
          * @param num pointer to a KSNumbers object describing the target epoch.
          */
         void precess(const KSNumbers *num);
 
 #ifdef UNIT_TEST
         friend class TestSkyPoint; // Test class
 #endif
 
     private:
         CachingDms RA0, Dec0; //catalog coordinates
         CachingDms RA, Dec;   //current true sky coordinates
         dms Alt, Az;
         static KSSun *m_Sun;
 
 
         // long version of these epochs
 #define J2000L          2451545.0L   //Julian Date for noon on Jan 1, 2000 (epoch J2000)
 #define B1950L          2433282.4235L // Julian date for Jan 0.9235, 1950
 
     protected:
         double lastPrecessJD { 0 }; // JD at which the last coordinate  (see updateCoords) for this SkyPoint was done
 };
 
 #ifndef KSTARS_LITE
 Q_DECLARE_METATYPE(SkyPoint)
 QDBusArgument &operator<<(QDBusArgument &argument, const SkyPoint &source);
 const QDBusArgument &operator>>(const QDBusArgument &argument, SkyPoint &dest);
 #endif