Merge lp:~registry/stellarium/socis2015-de430 into lp:stellarium

[gzotti]

A nice new feature for (pre)historical sky simulation or people needing extra accuracy. Thanks to support by ESA SoCiS2015 we have now optional access to precomputed planetary positions from NASA/JPL.

DE430&431 currently require manual download of data files. If files are available already, it is possible to use files from configured directory. Downloading should be integrated to the coming download manager.

More info in the branch description.

[lp:~registry/stellarium/socis2015-de430]

7760. By gzotti on 2016-01-16

cleanup a bit

[Alexander Wolf (alexwolf)]

I think GUI for VSOP/DE should be changed - using checkbox and chooser of the file for ephemeris files instead buttons seems better, IMHO.

[Alexander Wolf (alexwolf)]

review: Approve

[gzotti (georg-zotti)]

I don't want to add a file chooser here. I describe how to install files in the guide, and with the download manager on its way this will be replaced anyway soon.
Maybe changing to checkbox is more like the rest of GUI, I will do that.

[lp:~registry/stellarium/socis2015-de430]

7761. By gzotti on 2016-01-16

replaced DE43x buttons by checkboxes, some more cleanup

7762. By gzotti on 2016-01-16

removed unneeded manifest file

=== modified file '.bzrignore'
--- .bzrignore	2016-01-10 23:15:27 +0000
+++ .bzrignore	2016-01-16 17:00:50 +0000
@@ -1,20 +1,22 @@
 builds
+build
 installers
 .DS_Store
 CMakeLists.txt.user
 Stellarium.bat
 stellarium.iss
 stellarium-patch.iss
+stellarium.exe.manifest
 ./doc/qt.tag
 ./locale
 ./util/locations-editor/Makefile
 ./util/locations-editor/locations-editor
 ./util/locations-editor/locations-editor.pro.user
 ./util/copy-translations.bat
-build
 ./plugins/Observability/doc
 default_config.ini
 updates.json
+data/Info.plist
 guide/*.aux
 guide/*.log
 guide/*.idx
@@ -24,4 +26,5 @@
 guide/*.xml
 guide/*.synctex.gz
 * - Kopie.*
+*.~
 
 
=== modified file 'data/default_config.ini.cmake'
--- data/default_config.ini.cmake	2015-12-07 23:46:23 +0000
+++ data/default_config.ini.cmake	2016-01-16 17:00:50 +0000
@@ -264,6 +264,10 @@
 planet_magnitude_limit              = 6.5
 flag_nebula_magnitude_limit         = false
 nebula_magnitude_limit              = 8.5
+flag_use_de430                      = false
+flag_use_de431                      = false
+de430_path                          = ""
+de431_path                          = ""
 
 [init_location]
 location                            = auto
 
=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2016-01-11 16:48:05 +0000
+++ src/CMakeLists.txt	2016-01-16 17:00:50 +0000
@@ -178,12 +178,22 @@
      core/planetsephems/precession.h
      core/planetsephems/sidereal_time.c
      core/planetsephems/sidereal_time.h
-     core/planetsephems/stellplanet.c
-     core/planetsephems/stellplanet.h
+     #core/planetsephems/stellplanet.c   # replaced by EphemWrapper during de430 work
+     #core/planetsephems/stellplanet.h
+     core/planetsephems/jpl_int.h
+     core/planetsephems/jpleph.h
+     core/planetsephems/jpleph.cpp
+     core/planetsephems/EphemWrapper.cpp
+     core/planetsephems/EphemWrapper.hpp
+
      core/planetsephems/tass17.c
      core/planetsephems/tass17.h
      core/planetsephems/vsop87.c
      core/planetsephems/vsop87.h
+     core/planetsephems/de430.cpp
+     core/planetsephems/de430.hpp
+     core/planetsephems/de431.cpp
+     core/planetsephems/de431.hpp
 
      core/modules/Atmosphere.cpp
      core/modules/Atmosphere.hpp
 
=== modified file 'src/StelMainView.cpp'
--- src/StelMainView.cpp	2015-11-22 00:16:28 +0000
+++ src/StelMainView.cpp	2016-01-16 17:00:50 +0000
@@ -620,6 +620,9 @@
 	// plugins, because the gui create the QActions needed by some plugins.
 	StelApp::getInstance().initPlugIns();
 
+	// activate DE430/431 
+	StelApp::getInstance().getCore()->initEphemeridesFunctions();
+
 	// The script manager can only be fully initialized after the plugins have loaded.
 	StelApp::getInstance().initScriptMgr();
 
 
=== modified file 'src/core/StelCore.cpp'
--- src/core/StelCore.cpp	2016-01-06 15:10:45 +0000
+++ src/core/StelCore.cpp	2016-01-16 17:00:50 +0000
@@ -37,12 +37,17 @@
 #include "LandscapeMgr.hpp"
 #include "StelTranslator.hpp"
 #include "StelActionMgr.hpp"
+#include "StelFileMgr.hpp"
+#include "EphemWrapper.hpp"
 #include "precession.h"
 
 #include <QSettings>
 #include <QDebug>
 #include <QMetaEnum>
 
+#include <iostream>
+#include <fstream>
+
 // Init statics transfo matrices
 // See vsop87.doc:
 const Mat4d StelCore::matJ2000ToVsop87(Mat4d::xrotation(-23.4392803055555555556*(M_PI/180)) * Mat4d::zrotation(0.0000275*(M_PI/180)));
@@ -73,6 +78,10 @@
 	, jdOfLastJDUpdate(0.)
 	, deltaTCustomNDot(-26.0)
 	, deltaTCustomYear(1820.0)
+	, de430Available(false)
+	, de431Available(false)
+	, de430Active(false)
+	, de431Active(false)
 {
 	toneReproducer = new StelToneReproducer();
 
@@ -1928,3 +1937,74 @@
 {
 	return 2000.0 + (getJD() - 2451545.0)/365.25;
 }
+
+// DE430/DE431 handling
+
+bool StelCore::de430IsAvailable()
+{
+	return de430Available;
+}
+
+bool StelCore::de431IsAvailable()
+{
+	return de431Available;
+}
+
+bool StelCore::de430IsActive()
+{
+	return de430Active;
+}
+
+bool StelCore::de431IsActive()
+{
+	return de431Active;
+}
+
+void StelCore::setDe430Active(bool status)
+{
+	de430Active = de430Available && status;
+}
+
+void StelCore::setDe431Active(bool status)
+{
+	de431Active = de431Available && status;
+}
+
+void StelCore::initEphemeridesFunctions()
+{
+	QSettings* conf = StelApp::getInstance().getSettings();
+
+	QString de430ConfigPath = conf->value("astro/de430_path").toString();
+	QString de431ConfigPath = conf->value("astro/de431_path").toString();
+
+	QString de430FilePath;
+	QString de431FilePath;
+
+	//<-- DE430 -->
+	if(de430ConfigPath.remove(QChar('"')).isEmpty())
+		de430FilePath = StelFileMgr::findFile("ephem/" + QString(DE430_FILENAME), StelFileMgr::File);
+	else
+		de430FilePath = StelFileMgr::findFile(de430ConfigPath, StelFileMgr::File);
+
+	de430Available=!de430FilePath.isEmpty();
+	if(de430Available)
+	{
+		qDebug() << "DE430 at: " << de430FilePath;
+		EphemWrapper::init_de430(de430FilePath.toStdString().c_str());
+	}
+	setDe430Active(de430Available && conf->value("astro/flag_use_de430").toBool());
+
+	//<-- DE431 -->
+	if(de431ConfigPath.remove(QChar('"')).isEmpty())
+		de431FilePath = StelFileMgr::findFile("ephem/" + QString(DE431_FILENAME), StelFileMgr::File);
+	else
+		de431FilePath = StelFileMgr::findFile(de431ConfigPath, StelFileMgr::File);
+
+	de431Available=!de431FilePath.isEmpty();
+	if(de431Available)
+	{
+		qDebug() << "DE431 at: " << de431FilePath;
+		EphemWrapper::init_de431(de431FilePath.toStdString().c_str());
+	}
+	setDe431Active(de431Available && conf->value("astro/flag_use_de431").toBool());
+}
 
=== modified file 'src/core/StelCore.hpp'
--- src/core/StelCore.hpp	2015-12-29 12:14:13 +0000
+++ src/core/StelCore.hpp	2016-01-16 17:00:50 +0000
@@ -584,6 +584,16 @@
 	//! Get coefficients for custom equation for calculation of Delta-T
 	Vec3f getDeltaTCustomEquationCoefficients() const { return deltaTCustomEquationCoeff; }
 
+	//! initialize ephemerides calculation functions
+	void initEphemeridesFunctions();
+
+	bool de430IsAvailable(); //!< true if DE430 ephemeris file has been found
+	bool de431IsAvailable(); //!< true if DE431 ephemeris file has been found
+	bool de430IsActive();    //!< true if DE430 ephemeris is in use
+	bool de431IsActive();    //!< true if DE431 ephemeris is in use
+	void setDe430Active(bool status); //!< switch DE430 use to @param status (if de430IsAvailable()) DE430 is only used if date is within range of DE430.
+	void setDe431Active(bool status); //!< switch DE431 use to @param status (if de431IsAvailable()). DE431 is only used if DE430 is not used and the date is within range of DE431.
+
 signals:
 	//! This signal is emitted when the observer location has changed.
 	void locationChanged(StelLocation);
@@ -653,6 +663,12 @@
 	float deltaTCustomNDot;
 	float deltaTCustomYear;
 
+	// Variables for DE430/431 ephem calculation
+	bool de430Available; // ephem file found
+	bool de431Available; // ephem file found
+	bool de430Active;    // available and user-activated.
+	bool de431Active;    // available and user-activated.
+
 };
 
 #endif // _STELCORE_HPP_
 
=== modified file 'src/core/modules/SolarSystem.cpp'
--- src/core/modules/SolarSystem.cpp	2015-12-09 11:01:21 +0000
+++ src/core/modules/SolarSystem.cpp	2016-01-16 17:00:50 +0000
@@ -21,7 +21,7 @@
 
 #include "SolarSystem.hpp"
 #include "StelTexture.hpp"
-#include "stellplanet.h"
+#include "EphemWrapper.hpp"
 #include "Orbit.hpp"
 
 #include "StelProjector.hpp"
 
=== added file 'src/core/planetsephems/EphemWrapper.cpp'
--- src/core/planetsephems/EphemWrapper.cpp	1970-01-01 00:00:00 +0000
+++ src/core/planetsephems/EphemWrapper.cpp	2016-01-16 17:00:50 +0000
@@ -0,0 +1,400 @@
+/*
+Copyright (C) 2003 Fabien Chereau
+Copyright (C) 2015 Holger Niessner
+Copyright (C) 2015 Georg Zotti
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Library General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
+*/
+
+#include "EphemWrapper.hpp"
+#include "StelApp.hpp"
+#include "StelCore.hpp"
+#include "vsop87.h"
+#include "elp82b.h"
+#include "marssat.h"
+#include "l1.h"
+#include "tass17.h"
+#include "gust86.h"
+#include "de431.hpp"
+#include "de430.hpp"
+#include "pluto.h"
+
+#define EPHEM_MERCURY_ID  0
+#define EPHEM_VENUS_ID    1
+#define EPHEM_EMB_ID    2
+#define EPHEM_MARS_ID   3
+#define EPHEM_JUPITER_ID  4
+#define EPHEM_SATURN_ID   5
+#define EPHEM_URANUS_ID   6
+#define EPHEM_NEPTUNE_ID  7
+#define EPHEM_PLUTO_ID    8
+
+// GZ No idea what IMD stands for?
+//#define EPHEM_IMD_EARTH_ID 2
+#define EPHEM_JPL_EARTH_ID 3
+#define EPHEM_JPL_PLUTO_ID 9
+#define EPHEM_JPL_MOON_ID 10
+#define EPHEM_JPL_SUN_ID 11
+
+/**   JPL PLANET ID LIST
+**            1 = mercury           8 = neptune                             **
+**            2 = venus             9 = pluto                               **
+**            3 = earth            10 = moon                                **
+**            4 = mars             11 = sun                                 **
+**            5 = jupiter          12 = solar-system barycenter             **
+**            6 = saturn           13 = earth-moon barycenter               **
+**            7 = uranus 
+**/
+
+void EphemWrapper::init_de430(const char* filepath)
+{
+  InitDE430(filepath);
+}
+
+void EphemWrapper::init_de431(const char* filepath)
+{
+  InitDE431(filepath);
+}
+
+bool jd_fits_de431(const double jd)
+{
+	//Correct limits found via jpl_get_double(). Limits hardcoded to avoid calls each time.
+	//return !(jd < -3027215.5 || jd > 7930192.5);
+	//This limits inside those where sun can jump between ecliptic of date and ecliptic2000.
+	// We lose a month in -13000 and a few months in +17000, this should not matter.
+	return ((jd > -3027188.25 ) && (jd < 7930056.87916));
+}
+
+bool jd_fits_de430(const double jd)
+{
+	//return !(jd < 2287184.5 || jd > 2688974.5);
+	//return !(jd < 2287184.5 || jd > 2688976.5);
+	return ((jd > 2287184.5) && (jd < 2688976.5));
+}
+
+bool use_de430(const double jd)
+{
+    return StelApp::getInstance().getCore()->de430IsActive() &&
+        jd_fits_de430(jd);
+}
+
+bool use_de431(const double jd)
+{
+    return StelApp::getInstance().getCore()->de431IsActive() &&
+        jd_fits_de431(jd);
+}
+
+// planet_id is ONLY one of the #defined values 0..8 above.
+void get_planet_helio_coordsv(const double jd, double xyz[3], const int planet_id)
+{
+	bool deOk=false;
+	if(!std::isfinite(jd))
+	{
+		qDebug() << "get_planet_helio_coordsv(): SKIPPED CoordCalc, jd is infinite/nan: " << jd;
+		return;
+	}
+
+	if(use_de430(jd))
+	{
+		deOk=GetDe430Coor(jd, planet_id + 1, xyz);
+	}
+	else if(use_de431(jd))
+	{
+		deOk=GetDe431Coor(jd, planet_id + 1, xyz);
+	}
+	if (!deOk) //VSOP87 as fallback
+	{
+		GetVsop87Coor(jd, planet_id, xyz);
+	}
+}
+
+// Osculating positions for time JDE in elements for JDE0, if possible by the theory used (e.g. VSOP87).
+// For ephemerides like DE4xx, JDE0 is irrelevant.
+void get_planet_helio_osculating_coordsv(double jd0, double jd, double xyz[3], int planet_id)
+{
+	bool deOk=false;
+	if(!(std::isfinite(jd) && std::isfinite(jd0)))
+	{
+		qDebug() << "get_planet_helio_osculating_coordsv(): SKIPPED CoordCalc, jd0 or jd is infinite/nan. jd0:" << jd0 << "jd: "<< jd;
+		return;
+	}
+
+	if(use_de430(jd))
+	{
+		deOk=GetDe430Coor(jd, planet_id + 1, xyz);
+	}
+	else if(use_de431(jd))
+	{
+		deOk=GetDe431Coor(jd, planet_id + 1, xyz);
+	}
+	if (!deOk) //VSOP87 as fallback
+	{
+		GetVsop87OsculatingCoor(jd0, jd, planet_id, xyz);
+	}
+}
+
+/* Chapter 31 Pg 206-207 Equ 31.1 31.2, 31.3 using VSOP 87
+ * Calculate Pluto's rectangular heliocentric ecliptical coordinates
+ * for given Julian Day. Values are in AU.
+ * params : Julian day, rect coords */
+
+void get_pluto_helio_coordsv(double jd,double xyz[3], void* unused)
+{
+	Q_UNUSED(unused);
+	bool deOk=false;
+	if(!std::isfinite(jd))
+	{
+		qDebug() << "get_pluto_helio_coordsv(): SKIPPED PlutoCoordCalc, jd is infinite/nan:" << jd;
+		return;
+	}
+
+	if(use_de430(jd))
+	{
+		deOk=GetDe430Coor(jd, EPHEM_JPL_PLUTO_ID, xyz);
+	}
+	else if(use_de431(jd))
+	{
+		deOk=GetDe431Coor(jd, EPHEM_JPL_PLUTO_ID, xyz);
+	}
+	if (!deOk) // fallback to previous solution
+	{
+		get_pluto_helio_coords(jd, &xyz[0], &xyz[1], &xyz[2]);
+	}
+}
+
+/* Return 0 for the sun */
+void get_sun_helio_coordsv(double jd,double xyz[3], void* unused)
+{
+    xyz[0]=0.; xyz[1]=0.; xyz[2]=0.;
+}
+
+void get_mercury_helio_coordsv(double jd,double xyz[3], void* unused)
+{
+  	get_planet_helio_coordsv(jd, xyz, EPHEM_MERCURY_ID);
+}
+void get_venus_helio_coordsv(double jd,double xyz[3], void* unused)
+{
+  	get_planet_helio_coordsv(jd, xyz, EPHEM_VENUS_ID);
+}
+
+void get_earth_helio_coordsv(const double jd,double xyz[3], void* unused) 
+{
+	bool deOk=false;
+	if(!std::isfinite(jd))
+	{
+		qDebug() << "get_earth_helio_coordsv(): SKIPPED EarthCoordCalc, jd is infinite/nan:" << jd;
+		return;
+	}
+
+	if(use_de430(jd))
+	{
+		deOk=GetDe430Coor(jd, EPHEM_JPL_EARTH_ID, xyz);
+	}
+	else if(use_de431(jd))
+	{
+		deOk=GetDe431Coor(jd, EPHEM_JPL_EARTH_ID, xyz);
+	}
+	if (!deOk) //VSOP87 as fallback
+	{
+		double moon[3];
+		GetVsop87Coor(jd,EPHEM_EMB_ID,xyz);
+		GetElp82bCoor(jd,moon);
+		/* Earth != EMB:
+	0.0121505677733761 = mu_m/(1+mu_m),
+	mu_m = mass(moon)/mass(earth) = 0.01230002 */
+		xyz[0] -= 0.0121505677733761 * moon[0];
+		xyz[1] -= 0.0121505677733761 * moon[1];
+		xyz[2] -= 0.0121505677733761 * moon[2];
+	}
+}
+
+void get_mars_helio_coordsv(double jd,double xyz[3], void* unused)
+{
+	 get_planet_helio_coordsv(jd, xyz, EPHEM_MARS_ID);
+}
+
+void get_jupiter_helio_coordsv(double jd,double xyz[3], void* unused)
+{
+	 get_planet_helio_coordsv(jd, xyz, EPHEM_JUPITER_ID);
+}
+
+void get_saturn_helio_coordsv(double jd,double xyz[3], void* unused)
+{
+	 get_planet_helio_coordsv(jd, xyz, EPHEM_SATURN_ID);
+}
+
+void get_uranus_helio_coordsv(double jd,double xyz[3], void* unused)
+{
+	 get_planet_helio_coordsv(jd, xyz, EPHEM_URANUS_ID);
+}
+
+void get_neptune_helio_coordsv(double jd,double xyz[3], void* unused)
+{
+	 get_planet_helio_coordsv(jd, xyz, EPHEM_NEPTUNE_ID);
+}
+
+void get_mercury_helio_osculating_coords(double jd0,double jd,double xyz[3])
+{
+	 get_planet_helio_osculating_coordsv(jd0, jd, xyz, EPHEM_MERCURY_ID);
+}
+
+void get_venus_helio_osculating_coords(double jd0,double jd,double xyz[3])
+{
+	 get_planet_helio_osculating_coordsv(jd0, jd, xyz, EPHEM_VENUS_ID);
+}
+
+void get_earth_helio_osculating_coords(double jd0,double jd,double xyz[3])
+{
+	 get_planet_helio_osculating_coordsv(jd0, jd, xyz, EPHEM_EMB_ID);
+}
+
+void get_mars_helio_osculating_coords(double jd0,double jd,double xyz[3])
+{
+	 get_planet_helio_osculating_coordsv(jd0, jd, xyz, EPHEM_MARS_ID);
+}
+
+void get_jupiter_helio_osculating_coords(double jd0,double jd,double xyz[3])
+{
+	 get_planet_helio_osculating_coordsv(jd0, jd, xyz, EPHEM_JUPITER_ID);
+}
+
+void get_saturn_helio_osculating_coords(double jd0,double jd,double xyz[3])
+{
+	 get_planet_helio_osculating_coordsv(jd0, jd, xyz, EPHEM_SATURN_ID);
+}
+
+void get_uranus_helio_osculating_coords(double jd0,double jd,double xyz[3])
+{
+	 get_planet_helio_osculating_coordsv(jd0, jd, xyz, EPHEM_URANUS_ID);
+}
+
+void get_neptune_helio_osculating_coords(double jd0,double jd,double xyz[3])
+{
+	 get_planet_helio_osculating_coordsv(jd0, jd, xyz, EPHEM_NEPTUNE_ID);
+}
+
+/* Calculate the rectangular geocentric lunar coordinates to the inertial mean
+ * ecliptic and equinox of J2000.
+ * The geocentric coordinates returned are in units of AU.
+ * This function is based upon the Lunar Solution ELP2000-82B by
+ * Michelle Chapront-Touze and Jean Chapront of the Bureau des Longitudes,
+ * Paris. ELP 2000-82B theory
+ * param jd Julian day, rect pos */
+void get_lunar_parent_coordsv(double jde,double xyz[3], void* unused)
+{
+	bool deOk=false;
+	if(use_de430(jde))
+		deOk=GetDe430Coor(jde, EPHEM_JPL_MOON_ID, xyz, EPHEM_JPL_EARTH_ID);
+	else if(use_de431(jde))
+		deOk=GetDe431Coor(jde, EPHEM_JPL_MOON_ID, xyz, EPHEM_JPL_EARTH_ID);
+	if (!deOk) // fallback...
+		GetElp82bCoor(jde,xyz);
+}
+
+void get_phobos_parent_coordsv(double jd,double xyz[3], void* unused)
+{
+    GetMarsSatCoor(jd,MARS_SAT_PHOBOS,xyz);
+}
+
+void get_deimos_parent_coordsv(double jd,double xyz[3], void* unused)
+{
+    GetMarsSatCoor(jd,MARS_SAT_DEIMOS,xyz);
+}
+
+void get_io_parent_coordsv(double jd,double xyz[3], void* unused)
+{
+    GetL1Coor(jd,L1_IO,xyz);
+}
+
+void get_europa_parent_coordsv(double jd,double xyz[3], void* unused)
+{
+    GetL1Coor(jd,L1_EUROPA,xyz);
+}
+
+void get_ganymede_parent_coordsv(double jd,double xyz[3], void* unused)
+{
+    GetL1Coor(jd,L1_GANYMEDE,xyz);
+}
+
+void get_callisto_parent_coordsv(double jd,double xyz[3], void* unused)
+{
+    GetL1Coor(jd,L1_CALLISTO,xyz);
+}
+
+void get_mimas_parent_coordsv(double jd,double xyz[3], void* unused)
+{ 
+    GetTass17Coor(jd,TASS17_MIMAS,xyz);
+}
+
+void get_enceladus_parent_coordsv(double jd,double xyz[3], void* unused)
+{ 
+    GetTass17Coor(jd,TASS17_ENCELADUS,xyz);
+}
+
+void get_tethys_parent_coordsv(double jd,double xyz[3], void* unused)
+{ 
+    GetTass17Coor(jd,TASS17_TETHYS,xyz);
+}
+
+void get_dione_parent_coordsv(double jd,double xyz[3], void* unused)
+{ 
+    GetTass17Coor(jd,TASS17_DIONE,xyz);
+}
+
+void get_rhea_parent_coordsv(double jd,double xyz[3], void* unused)
+{ 
+    GetTass17Coor(jd,TASS17_RHEA,xyz);
+}
+
+void get_titan_parent_coordsv(double jd,double xyz[3], void* unused)
+{ 
+    GetTass17Coor(jd,TASS17_TITAN,xyz);
+}
+
+void get_hyperion_parent_coordsv(double jd,double xyz[3], void* unused)
+{ 
+    GetTass17Coor(jd,TASS17_HYPERION,xyz);
+}
+
+void get_iapetus_parent_coordsv(double jd,double xyz[3], void* unused)
+{ 
+    GetTass17Coor(jd,TASS17_IAPETUS,xyz);
+}
+
+void get_miranda_parent_coordsv(double jd,double xyz[3], void* unused)
+{
+    GetGust86Coor(jd,GUST86_MIRANDA,xyz);
+}
+
+void get_ariel_parent_coordsv(double jd,double xyz[3], void* unused)
+{
+    GetGust86Coor(jd,GUST86_ARIEL,xyz);
+}
+
+void get_umbriel_parent_coordsv(double jd,double xyz[3], void* unused)
+{
+    GetGust86Coor(jd,GUST86_UMBRIEL,xyz);
+}
+
+void get_titania_parent_coordsv(double jd,double xyz[3], void* unused)
+{
+    GetGust86Coor(jd,GUST86_TITANIA,xyz);
+}
+
+void get_oberon_parent_coordsv(double jd,double xyz[3], void* unused)
+{
+    GetGust86Coor(jd,GUST86_OBERON,xyz);
+}
+
 
=== added file 'src/core/planetsephems/EphemWrapper.hpp'
--- src/core/planetsephems/EphemWrapper.hpp	1970-01-01 00:00:00 +0000
+++ src/core/planetsephems/EphemWrapper.hpp	2016-01-16 17:00:50 +0000
@@ -0,0 +1,92 @@
+/*
+Copyright (C) 2003 Fabien Chereau
+Copyright (C) 2015 Holger Niessner
+Copyright (C) 2015 Georg Zotti
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Library General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
+*/
+
+/*
+ * This class provides a wrapper to multiple methods to calculate ephemerides.
+ * Depending on availability of extra data files, the class uses:
+ * - VSOP87 and ELP82B
+ * - DE430
+ * - DE431
+ *
+ * Extending the old stellplanet-class, this updated version now
+ * includes access to DE430 and DE431 for a more precise, yet storage-space intensive solution.
+ */
+
+#ifndef _EPHEMWRAPPER_HPP_
+#define _EPHEMWRAPPER_HPP_
+
+#define DE430_FILENAME  "linux_p1550p2650.430"
+#define DE431_FILENAME  "lnxm13000p17000.431"
+
+class EphemWrapper{
+public:
+    static void init_de430(const char* filepath);
+    static void init_de431(const char* filepath);
+};
+
+void get_sun_helio_coordsv(double jd,double xyz[3], void*);
+void get_mercury_helio_coordsv(double jd,double xyz[3], void*);
+void get_venus_helio_coordsv(double jd,double xyz[3], void*);
+void get_earth_helio_coordsv(double jd,double xyz[3], void*);
+void get_mars_helio_coordsv(double jd,double xyz[3], void*);
+void get_jupiter_helio_coordsv(double jd,double xyz[3], void*);
+void get_saturn_helio_coordsv(double jd,double xyz[3], void*);
+void get_uranus_helio_coordsv(double jd,double xyz[3], void*);
+void get_neptune_helio_coordsv(double jd,double xyz[3], void*);
+void get_pluto_helio_coordsv(double jd,double xyz[3], void*);
+
+void get_mercury_helio_osculating_coords(double jd0,double jd,double xyz[3]);
+void get_venus_helio_osculating_coords(double jd0,double jd,double xyz[3]);
+void get_earth_helio_osculating_coords(double jd0,double jd,double xyz[3]);
+void get_mars_helio_osculating_coords(double jd0,double jd,double xyz[3]);
+void get_jupiter_helio_osculating_coords(double jd0,double jd,double xyz[3]);
+void get_saturn_helio_osculating_coords(double jd0,double jd,double xyz[3]);
+void get_uranus_helio_osculating_coords(double jd0,double jd,double xyz[3]);
+void get_neptune_helio_osculating_coords(double jd0,double jd,double xyz[3]);
+void get_pluto_helio_osculating_coords(double jd0,double jd,double xyz[3]);
+
+void get_lunar_parent_coordsv(double jde, double xyz[3], void*);
+
+void get_phobos_parent_coordsv(double jd,double xyz[3], void*);
+void get_deimos_parent_coordsv(double jd,double xyz[3], void*);
+
+void get_io_parent_coordsv(double jd,double xyz[3], void*);
+void get_europa_parent_coordsv(double jd,double xyz[3], void*);
+void get_ganymede_parent_coordsv(double jd,double xyz[3], void*);
+void get_callisto_parent_coordsv(double jd,double xyz[3], void*);
+
+void get_mimas_parent_coordsv(double jd,double xyz[3], void*);
+void get_enceladus_parent_coordsv(double jd,double xyz[3], void*);
+void get_tethys_parent_coordsv(double jd,double xyz[3], void*);
+void get_dione_parent_coordsv(double jd,double xyz[3], void*);
+void get_rhea_parent_coordsv(double jd,double xyz[3], void*);
+void get_titan_parent_coordsv(double jd,double xyz[3], void*);
+void get_hyperion_parent_coordsv(double jd,double xyz[3], void*);
+void get_iapetus_parent_coordsv(double jd,double xyz[3], void*);
+
+void get_miranda_parent_coordsv(double jd,double xyz[3], void*);
+void get_ariel_parent_coordsv(double jd,double xyz[3], void*);
+void get_umbriel_parent_coordsv(double jd,double xyz[3], void*);
+void get_titania_parent_coordsv(double jd,double xyz[3], void*);
+void get_oberon_parent_coordsv(double jd,double xyz[3], void*);
+
+#endif // _EPHEMWRAPPER_HPP_
+
+
 
=== added file 'src/core/planetsephems/README.txt'
--- src/core/planetsephems/README.txt	1970-01-01 00:00:00 +0000
+++ src/core/planetsephems/README.txt	2016-01-16 17:00:50 +0000
@@ -0,0 +1,54 @@
+README
+=======
+This Readme gives instructions on how to enable DE430 and/or DE431 for Stellarium for 
+more accurate planetary positions.
+
+DE430 covers the dates from 1.Jan 1550 to 22. Jan 2650 with higher precision, whereas 
+DE431 covers a longer period of time, from 13201 BC to AD 17191. 
+Both are more precise than the standard VSOP87 algorithm used in Stellarium. 
+
+When one or both files are used as described below, 
+the algorithm will switch according to the current time displayed in Stellarium and
+calculate the planetary positions using the preferred method.
+
+Instructions
+============
+
+File description
+================
+The following files, which can be obtained from 
+ftp://ssd.jpl.nasa.gov/pub/eph/planets/Linux/, have to be used:
+
+DE430: linux_p1550p2650.430 (md5 hash 707c4262533d52d59abaaaa5e69c5738)
+DE431: lnxm13000p17000.431 (md5 hash fad0f432ae18c330f9e14915fbf8960a)
+
+File Placement
+==============
+The above mentioned files have to be placed in a folder named 'ephem' inside the 
+'Installation Data Directory' (see http://www.stellarium.org/doc/head/fileStructure.html).
+
+This is directory is different on the supported operating systems:
+    - On Linux / BSD / other POSIX: 
+    It depends on the installation prefix used when building Stellarium. 
+    If you built from source, and didn't explicitly specify an install prefix, 
+    the prefix will be /usr/local. Typically, pre-built packages for distros will use 
+    the /usr prefix. The Installation Data Directory is $PREFIX/share/stellarium
+    
+    - On Windows:
+    It depends on where Stellarium is installed. 
+    The main Stellarium installation directory is the Installation Data Directory. 
+    Typically this will be C:\Program Files\Stellarium\
+    
+    - On MacOS X:
+    The Installation Data Directory is found inside the application bundle. 
+
+Already placed in the 'Installation Data Directory' should be folders such as 'data', 
+'landscapes', 'stars', 'textures',...
+
+_ IDD
+  \_ data
+  \_ landscapes
+  \_ stars
+  \_ ephem
+    \_ linux_p1550p2650.430
+    \_ lnxm13000p17000.431
 
=== added file 'src/core/planetsephems/de430.cpp'
--- src/core/planetsephems/de430.cpp	1970-01-01 00:00:00 +0000
+++ src/core/planetsephems/de430.cpp	2016-01-16 17:00:50 +0000
@@ -0,0 +1,120 @@
+/*
+Copyright (c) 2015 Holger Niessner
+Copyright (c) 2016 Georg Zotti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#include "de430.hpp"
+#include "StelUtils.hpp"
+#include "StelCore.hpp"
+#include "StelApp.hpp"
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+static void * ephem;
+
+static Vec3d tempECL = Vec3d(0,0,0);
+static Vec3d tempICRF = Vec3d(0,0,0);
+static char nams[JPL_MAX_N_CONSTANTS][6];
+static double vals[JPL_MAX_N_CONSTANTS];
+static double tempXYZ[6];
+
+static bool initDone = false;
+
+void InitDE430(const char* filepath)
+{
+	ephem = jpl_init_ephemeris(filepath, nams, vals);
+
+	if(jpl_init_error_code() != 0)
+	{
+		StelApp::getInstance().getCore()->setDe430Active(false);
+		qDebug() << "Error "<< jpl_init_error_code() << "at DE430 init:" << jpl_init_error_message();
+	}
+	else
+	{
+		initDone = true;
+		double jd1, jd2;
+		jd1=jpl_get_double(ephem, JPL_EPHEM_START_JD);
+		jd2=jpl_get_double(ephem, JPL_EPHEM_END_JD);
+		qDebug() << "DE430 init successful. startJD=" << QString::number(jd1, 'f', 4) << "endJD=" << QString::number(jd2, 'f', 4);
+	}
+}
+
+void TerminateDE430()
+{
+  jpl_close_ephemeris(ephem);
+}
+
+bool GetDe430Coor(const double jde, const int planet_id, double * xyz, const int centralBody_id)
+{
+    if(initDone)
+    {
+	// This may return some error code!
+	int jplresult=jpl_pleph(ephem, jde, planet_id, centralBody_id, tempXYZ, 0);
+
+	switch (jplresult)
+	{
+		case 0: // all OK.
+			break;
+		case JPL_EPH_OUTSIDE_RANGE:
+			qDebug() << "GetDe430Coor: JPL_EPH_OUTSIDE_RANGE at jde" << jde << "for planet" << planet_id;
+			return false;
+			break;
+		case JPL_EPH_READ_ERROR:
+			qDebug() << "GetDe430Coor: JPL_EPH_READ_ERROR at jde" << jde << "for planet" << planet_id;
+			return false;
+			break;
+		case JPL_EPH_QUANTITY_NOT_IN_EPHEMERIS:
+			qDebug() << "GetDe430Coor: JPL_EPH_QUANTITY_NOT_IN_EPHEMERIS at jde" << jde << "for planet" << planet_id;
+			return false;
+			break;
+		case JPL_EPH_INVALID_INDEX:
+			qDebug() << "GetDe430Coor: JPL_EPH_INVALID_INDEX at jde" << jde << "for planet" << planet_id;
+			return false;
+			break;
+		case JPL_EPH_FSEEK_ERROR:
+			qDebug() << "GetDe430Coor: JPL_EPH_FSEEK_ERROR at jde" << jde << "for planet" << planet_id;
+			return false;
+			break;
+		default: // Should never happen...
+			qDebug() << "GetDe430Coor: unknown error" << jplresult << "at jde" << jde << "for planet" << planet_id;
+			return false;
+			break;
+	}
+
+	jpl_pleph(ephem, jde, planet_id, centralBody_id, tempXYZ, 0);
+
+        tempICRF = Vec3d(tempXYZ[0], tempXYZ[1], tempXYZ[2]);
+        tempECL = StelCore::matJ2000ToVsop87 * tempICRF;
+
+        xyz[0] = tempECL[0];
+        xyz[1] = tempECL[1];
+        xyz[2] = tempECL[2];
+	return true;
+    }
+    return false;
+}
+
+
+#ifdef __cplusplus
+  }
+#endif
 
=== added file 'src/core/planetsephems/de430.hpp'
--- src/core/planetsephems/de430.hpp	1970-01-01 00:00:00 +0000
+++ src/core/planetsephems/de430.hpp	2016-01-16 17:00:50 +0000
@@ -0,0 +1,44 @@
+/*
+Copyright (c) 2015 Holger Niessner
+Copyright (c) 2016 Georg Zotti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef _DE430_HPP_
+#define _DE430_HPP_
+
+#include "jpleph.h"
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+void InitDE430(const char* filepath);
+// most of the time centralBody_id likely is the Sun. However, for Moon, use centralBody_id=EPHEM_JPL_EARTH_ID=3
+// return true if OK, false if something was wrong with the JPL functions. In this case, see log for details.
+bool GetDe430Coor(const double jde, const int planet_id, double * xyz, const int centralBody_id=CENTRAL_PLANET_ID);
+// Not possible for a DE.
+//void GetDe430OsculatingCoor(double jd0, double jd, int planet_id, double *xyz, const int centralBody_id=CENTRAL_PLANET_ID);
+
+#ifdef __cplusplus
+    }
+#endif
+
+#endif
 
=== added file 'src/core/planetsephems/de431.cpp'
--- src/core/planetsephems/de431.cpp	1970-01-01 00:00:00 +0000
+++ src/core/planetsephems/de431.cpp	2016-01-16 17:00:50 +0000
@@ -0,0 +1,119 @@
+/*
+Copyright (c) 2015 Holger Niessner
+Copyright (c) 2016 Georg Zotti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#include "de431.hpp"
+#include "jpleph.h"
+#include "StelUtils.hpp"
+#include "StelCore.hpp"
+#include "StelApp.hpp"
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+static void * ephem;
+   
+static Vec3d tempECL = Vec3d(0,0,0);
+static Vec3d tempICRF = Vec3d(0,0,0);
+static char nams[JPL_MAX_N_CONSTANTS][6];
+static double vals[JPL_MAX_N_CONSTANTS];
+static double tempXYZ[6];
+
+static bool initDone = false;
+
+void InitDE431(const char* filepath)
+{
+	ephem = jpl_init_ephemeris(filepath, nams, vals);
+
+	if(jpl_init_error_code() != 0)
+	{
+		StelApp::getInstance().getCore()->setDe431Active(false);
+		qDebug() << "Error "<< jpl_init_error_code() << "at DE431 init:" << jpl_init_error_message();
+	}
+	else
+	{
+		initDone = true;
+		double jd1, jd2;
+		jd1=jpl_get_double(ephem, JPL_EPHEM_START_JD);
+		jd2=jpl_get_double(ephem, JPL_EPHEM_END_JD);
+		qDebug() << "DE431 init successful. startJD=" << QString::number(jd1, 'f', 4) << "endJD=" << QString::number(jd2, 'f', 4);
+	}
+}
+
+void TerminateDE431()
+{
+  jpl_close_ephemeris(ephem);
+}
+
+bool GetDe431Coor(const double jde, const int planet_id, double * xyz, const int centralBody_id)
+{
+    if(initDone)
+    {
+	// This may return some error code!
+	int jplresult=jpl_pleph(ephem, jde, planet_id, centralBody_id, tempXYZ, 0);
+
+	switch (jplresult)
+	{
+		case 0: // all OK.
+			break;
+		case JPL_EPH_OUTSIDE_RANGE:
+			qDebug() << "GetDe431Coor: JPL_EPH_OUTSIDE_RANGE at jde" << jde << "for planet" << planet_id;
+			return false;
+			break;
+		case JPL_EPH_READ_ERROR:
+			qDebug() << "GetDe431Coor: JPL_EPH_READ_ERROR at jde" << jde << "for planet" << planet_id;
+			return false;
+			break;
+		case JPL_EPH_QUANTITY_NOT_IN_EPHEMERIS:
+			qDebug() << "GetDe431Coor: JPL_EPH_QUANTITY_NOT_IN_EPHEMERIS at jde" << jde << "for planet" << planet_id;
+			return false;
+			break;
+		case JPL_EPH_INVALID_INDEX:
+			qDebug() << "GetDe431Coor: JPL_EPH_INVALID_INDEX at jde" << jde << "for planet" << planet_id;
+			return false;
+			break;
+		case JPL_EPH_FSEEK_ERROR:
+			qDebug() << "GetDe431Coor: JPL_EPH_FSEEK_ERROR at jde" << jde << "for planet" << planet_id;
+			return false;
+			break;
+		default: // Should never happen...
+			qDebug() << "GetDe431Coor: unknown error" << jplresult << "at jde" << jde << "for planet" << planet_id;
+			return false;
+			break;
+	}
+
+        tempICRF = Vec3d(tempXYZ[0], tempXYZ[1], tempXYZ[2]);
+        tempECL = StelCore::matJ2000ToVsop87 * tempICRF;
+
+        xyz[0] = tempECL[0];
+        xyz[1] = tempECL[1];
+        xyz[2] = tempECL[2];
+	return true;
+    }
+    return false;
+}
+
+
+#ifdef __cplusplus
+  }
+#endif
 
=== added file 'src/core/planetsephems/de431.hpp'
--- src/core/planetsephems/de431.hpp	1970-01-01 00:00:00 +0000
+++ src/core/planetsephems/de431.hpp	2016-01-16 17:00:50 +0000
@@ -0,0 +1,44 @@
+/*
+Copyright (c) 2015 Holger Niessner
+Copyright (c) 2016 Georg Zotti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef _DE431_HPP_
+#define _DE431_HPP_
+
+#include "jpleph.h"
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+void InitDE431(const char* filepath);
+// most of the time centralBody_id likely is the Sun. However, for Moon, use centralBody_id=EPHEM_JPL_EARTH_ID=3
+// return true if OK, false if something was wrong with the JPL functions. In this case, see log for details.
+bool GetDe431Coor(const double jde, const int planet_id, double * xyz, const int centralBody_id=CENTRAL_PLANET_ID);
+// Not possible for a DE.
+//void GetDe431OsculatingCoor(double jd0, double jd, int planet_id, double *xyz, const int centralBody_id=CENTRAL_PLANET_ID);
+
+#ifdef __cplusplus
+    }
+#endif
+
+#endif
 
=== added file 'src/core/planetsephems/jpl_int.h'
--- src/core/planetsephems/jpl_int.h	1970-01-01 00:00:00 +0000
+++ src/core/planetsephems/jpl_int.h	2016-01-16 17:00:50 +0000
@@ -0,0 +1,106 @@
+/* jpl_int.cpp: internal definitions for JPL ephemeris functions
+
+Copyright (C) 2011, Project Pluto
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.    */
+
+            /* A JPL binary ephemeris header contains five doubles and */
+            /* (up to) 41 int32_t integers,  so:                          */
+#define JPL_HEADER_SIZE (5 * sizeof( double) + 41 * sizeof( int32_t))
+            /* ...also known as 5 * 8 + 41 * 4 = 204 bytes.   */
+
+
+            /* Thus far,  no DE ephems use eighteen terms in the Chebyshev */
+            /* expansion.  There's an assert to catch it if this changes.. */
+#define MAX_CHEBY          18
+
+#pragma pack(1)
+
+struct interpolation_info
+   {
+   double posn_coeff[MAX_CHEBY], vel_coeff[MAX_CHEBY], twot;
+   unsigned n_posn_avail, n_vel_avail;
+   };
+
+struct jpl_eph_data {
+   double ephem_start, ephem_end, ephem_step;
+   uint32_t ncon;
+   double au;
+   double emrat;
+   uint32_t ipt[15][3];
+   uint32_t ephemeris_version;
+               /* This is the end of the file header.  Following are */
+               /* items computed within my code.                     */
+   uint32_t kernel_size, recsize, ncoeff;
+   uint32_t swap_bytes;
+   uint32_t curr_cache_loc;
+   double pvsun[9];
+   double pvsun_t;
+   double *cache;
+   struct interpolation_info iinfo;
+   FILE *ifile;
+   };
+#pragma pack()
+
+/* 2014 Mar 25:  notes about the file structure :
+
+Bytes 0- 83:  first line ("JPL Planetary Ephemeris DExxx/LExxx")
+     84-167:  second line ("Start Epoch: JED = ttttttt.t yyyy-MMM-dd 00:00:00")
+    168-251:  third line ("Final Epoch: JED = ttttttt.t yyyy-MMM-dd 00:00:00")
+    252-257:  first constant name ("DENUM ")
+    252+6n to 257+6n:   nth constant name (0 <= n < 399)
+    2646-2651:  400th constant name
+    2652-2659:   ephem_start
+    2660-2667:   ephem_end
+    2668-2675:   ephem_step
+    2676-2679:   ncon
+    2680-2687:   AU in km: close to 149597870.700000
+    2688-2695:   Earth/moon mass ratio: about 81.300569
+         ...followed by 36 32-bit ints for the above 'ipt' array [12][3]...
+    2840-2843:   ephemeris version (405,  430,  etc.)
+         ...followed by three 32-bit ints for ipt[12][0...2].
+    2844-2855:   ipt[12][0], ipt[12][1], ipt[12][2]
+         Note that in the JPL FORTRAN code,
+         ipt[12][0..2] become lpt[0..2] (the lunar libration offsets);
+         ipt[13][0..2] become rpt[0..2] (the lunar euler angle rate offsets);
+         ipt[14][0..2] become tpt[0..2] (the TT-TDB offsets)
+         Further note that ipt[13] and [14] are new to DE-430t.  In older
+         versions,  they're just zeroes.
+    2856-2861:  name of 401th constant
+    2862-2867:  name of 402st constant
+         ...and after the last constant,  ipt[13][0..2] and ipt[14][0..2].
+         If n_constants <= 400,  these will occupy bytes 2856-2879.  Otherwise,
+         add (n_constants - 400) * 6 to get the byte offset.
+
+         Notice that _most_ of the data in the jpl_eph_data struct is stored
+         between bytes 2652 to 2839.  That gets us up to ipt[11][2].  In a
+         sensible world,  this would be followed by ipt[12][0].  However,  it
+         used to be that DE just gave eleven variables;  librations and
+         TT-TDB are sort of an afterthought.  And furthermore,  having more
+         than 400 constants was something of an afterthought,  too.  So you
+         have ipts[0] to [11] stored contiguously;  then four bytes for the
+         ephemeris version are stuck in there;  then twelve bytes for ipt[12],
+         which may be zero;  then any "extra" (past 400) constant names;
+         and _then_ 24 bytes for ipt[13] and ipt[14].
+
+   recsize-recsize+8*ncon: actual values of the constants.
+         recsize = 8 * ncoeff;  ncoeff,  thus far,  has been...
+         ncoeff = 773 for DE-102
+         ncoeff = 826 for DE-200 & 202
+         ncoeff = 1018 for DE-403, 405, 406, 410, 414, 421, 422, 423, 424, 430, 431,
+         ncoeff = 728 for DE-406
+         ncoeff = 982 for DE-432, DE-432t
+*/
 
=== added file 'src/core/planetsephems/jpleph.cpp'
--- src/core/planetsephems/jpleph.cpp	1970-01-01 00:00:00 +0000
+++ src/core/planetsephems/jpleph.cpp	2016-01-16 17:00:50 +0000
@@ -0,0 +1,978 @@
+/* jpleph.cpp: JPL ephemeris functions
+
+Copyright (C) 2011, Project Pluto
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.    */
+
+/*****************************************************************************
+*        *****    jpl planetary and lunar ephemerides    *****     C ver.1.2 *
+******************************************************************************
+*                                                                            *
+*  This program was written in standard fortran-77 and it was manually       *
+*  translated to C language by Piotr A. Dybczynski ([e-mail]),  *
+*  subsequently revised heavily by Bill J Gray ([e-mail]),  just short  *
+*  of a total re-write.                                                      *
+*                                                                            *
+******************************************************************************
+*                 Last modified: July 23, 1997 by PAD                        *
+******************************************************************************
+21 Apr 2010:  Revised by Bill J. Gray.  The code now determines the kernel
+size,  then allocates memory accordingly.  This should 'future-proof' us in
+case JPL (or someone else) creates kernels that are larger than the previously
+arbitrary MAX_KERNEL_SIZE parameter.  'swap_long' and 'swap_double' have
+been replaced with 'swap_32_bit_val' and 'swap_64_bit_val'.  It also works
+on 64-bit compiles now.
+
+16 Mar 2001:  Revised by Bill J. Gray.  You can now use binary
+ephemerides with either byte order ('big-endian' or 'small-endian');
+the code checks to see if the data is in the "wrong" order for the
+current platform,  and swaps bytes on-the-fly if needed.  (Yes,  this
+can result in a slowdown... sometimes as much as 1%.  The function is
+so mathematically intensive that the byte-swapping is the least of our
+troubles.)  You can also use DE-200, 403, 404, 405,  or 406 without
+recompiling (the constan() function now determines which ephemeris is
+in use and its byte order).
+
+Also,  I did some minor optimization of the interp() (Chebyshev
+interpolation) function,  resulting in a bit of a speedup.
+
+The code has been modified to be a separately linkable component,  with
+details of the implementation encapsulated.
+*****************************************************************************/
+
+#include <stdio.h>
+#include <assert.h>
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "StelUtils.hpp"
+/**** include variable and type definitions, specific for this C version */
+
+#include "jpleph.h"
+#include "jpl_int.h"
+
+#define TRUE 1
+#define FALSE 0
+
+
+// GZ patches for Large File Support for DE431 past AD10100...
+#if defined(Q_OS_WIN)
+#define FSeek(__FILE, __OFFSET, _MODE) _fseeki64(__FILE, __OFFSET, _MODE)
+#else
+#define FSeek(__FILE, __OFFSET, _MODE) fseeko(__FILE, __OFFSET, _MODE)
+#endif
+
+
+double DLL_FUNC jpl_get_double(const void *ephem, const int value)
+{
+   return(*(double *)((char *)ephem + value));
+}
+
+long DLL_FUNC jpl_get_long(const void *ephem, const int value)
+{
+   return(*(int32_t *)((char *)ephem + value));
+}
+
+
+/*****************************************************************************
+**           jpl_pleph(ephem,et,ntar,ncent,rrd,calc_velocity)              **
+******************************************************************************
+**                                                                          **
+**    This subroutine reads the jpl planetary ephemeris                     **
+**    and gives the position and velocity of the point 'ntarg'              **
+**    with respect to 'ncent'.                                              **
+**                                                                          **
+**    Calling sequence parameters:                                          **
+**                                                                          **
+**      et = (double) julian ephemeris date at which interpolation          **
+**           is wanted.                                                     **
+**                                                                          **
+**    ntarg = integer number of 'target' point.                             **
+**                                                                          **
+**    ncent = integer number of center point.                               **
+**                                                                          **
+**    The numbering convention for 'ntarg' and 'ncent' is:                  **
+**                                                                          **
+**            1 = mercury           8 = neptune                             **
+**            2 = venus             9 = pluto                               **
+**            3 = earth            10 = moon                                **
+**            4 = mars             11 = sun                                 **
+**            5 = jupiter          12 = solar-system barycenter             **
+**            6 = saturn           13 = earth-moon barycenter               **
+**            7 = uranus           14 = nutations (longitude and obliq)     **
+**                                 15 = librations, if on eph. file         **
+**                                 16 = lunar mantle omega_x,omega_y,omega_z**
+**                                 17 = TT-TDB, if on eph. file             **
+**                                                                          **
+**            (If nutations are wanted, set ntarg = 14.                     **
+**             For librations, set ntarg = 15. set ncent= 0.                **
+**             For TT-TDB,  set ntarg = 17.  I've not actually              **
+**             seen an ntarg = 16 case yet.)                                **
+**                                                                          **
+**     rrd = output 6-element, double array of position and velocity        **
+**           of point 'ntarg' relative to 'ncent'. The units are au and     **
+**           au/day. For librations the units are radians and radians       **
+**           per day. In the case of nutations the first four words of      **
+**           rrd will be set to nutations and rates, having units of        **
+**           radians and radians/day.                                       **
+**                                                                          **
+**           The option is available to have the units in km and km/sec.    **
+**           for this, set km=TRUE at the beginning of the program.         **
+**                                                                          **
+**     calc_velocity = integer flag;  if nonzero,  velocities will be       **
+**           computed,  otherwise not.                                      **
+**                                                                          **
+*****************************************************************************/
+int DLL_FUNC jpl_pleph(void *ephem, const double et, const int ntarg,
+                      const int ncent, double rrd[], const int calc_velocity)
+{
+    struct jpl_eph_data *eph = (struct jpl_eph_data *)ephem;
+    double pv[13][6];/* pv is the position/velocity array
+                             NUMBERED FROM ZERO: 0=Mercury,1=Venus,...
+                             8=Pluto,9=Moon,10=Sun,11=SSBary,12=EMBary
+                             First 10 elements (0-9) are affected by
+                             jpl_state(), all are adjusted here.         */
+
+
+    int rval = 0;
+    const int list_val = (calc_velocity ? 2 : 1);
+    unsigned i;
+    int list[14];    /* list is a vector denoting, for which "body"
+                            ephemeris values should be calculated by
+                            jpl_state():  0=Mercury,1=Venus,2=EMBary,...,
+                            8=Pluto,  9=geocentric Moon, 10=nutations in
+                            long. & obliq.  11= lunar librations;
+                            12 = TT-TDB, 13=lunar mantle omegas */
+
+    for(i = 0; i < 6; ++i) rrd[i] = 0.0;
+
+    if(ntarg == ncent) return(0);
+
+    for(i = 0; i < sizeof(list) / sizeof(list[0]); i++)
+      list[i] = 0;
+
+         /* Because of the whacko indexing in JPL ephemerides,  we need */
+         /* to work out way through the following indexing schemes :   */
+         /* ntarg       ipt         list     */
+         /*  14          11          10      Nutations */
+         /*  15          12          11      Librations */
+         /*  16          13          12      Lunar mantle angular vel */
+         /*  17          14          13      TT - TDB */
+
+    for(i = 0; i < 4; i++)
+      if(ntarg == (int)i + 14)
+      {
+        if(eph->ipt[i + 11][1] > 0) /* quantity is in ephemeris */
+        {
+          list[i + 10] = list_val;
+          rval = jpl_state(ephem, et, list, pv, rrd, 0);
+        }
+        else          /*  quantity doesn't exist in the ephemeris file  */
+          rval = JPL_EPH_QUANTITY_NOT_IN_EPHEMERIS;
+        return(rval);
+      }
+    if(ntarg > 13 || ncent > 13 || ntarg < 1 || ncent < 1)
+      return(JPL_EPH_INVALID_INDEX);
+
+/*  force barycentric output by 'state'     */
+
+/*  set up proper entries in 'list' array for state call     */
+
+    for(i = 0; i < 2; i++) /* list[] IS NUMBERED FROM ZERO ! */
+    {
+      const unsigned k = (i ? ncent : ntarg) - 1;
+
+      if(k <= 9) list[k] = list_val;   /* Major planets */
+      if(k == 9) list[2] = list_val;   /* for moon,  earth state is needed */
+      if(k == 2) list[9] = list_val;   /* for earth,  moon state is needed */
+      if(k == 12) list[2] = list_val;  /* EMBary state additionally */
+    }
+
+  /*   make call to state   */
+   rval = jpl_state(eph, et, list, pv, rrd, 1);
+   /* Solar System barycentric Sun state goes to pv[10][] */
+   if(ntarg == 11 || ncent == 11)
+      for(i = 0; i < 6; i++)
+         pv[10][i] = eph->pvsun[i];
+
+   /* Solar System Barycenter coordinates & velocities equal to zero */
+   if(ntarg == 12 || ncent == 12)
+      for(i = 0; i < 6; i++)
+         pv[11][i] = 0.0;
+
+   /* Solar System barycentric EMBary state:  */
+   if(ntarg == 13 || ncent == 13)
+      for(i = 0; i < 6; i++)
+         pv[12][i] = pv[2][i];
+
+   /* if moon from earth or earth from moon ..... */
+   if((ntarg*ncent) == 30 && (ntarg+ncent) == 13)
+      for(i = 0; i < 6; ++i) pv[2][i]=0.0;
+   else
+      {
+      if(list[2])           /* calculate earth state from EMBary */
+         for(i = 0; i < list[2] * 3u; ++i)
+            pv[2][i] -= pv[9][i]/(1.0+eph->emrat);
+
+      if(list[9]) /* calculate Solar System barycentric moon state */
+         for(i = 0; i < list[9] * 3u; ++i)
+            pv[9][i] += pv[2][i];
+      }
+
+   for(i = 0; i < list_val * 3u; ++i)
+      rrd[i] = pv[ntarg-1][i] - pv[ncent-1][i];
+
+   return(rval);
+}
+
+/* Some notes about the information stored in 'iinfo':  the posn_coeff[]
+array contains the Chebyshev polynomials for tc,
+
+posn_coeff[i]=T (tc).
+               i
+
+The vel_coeff[] array contains the derivatives of the same polynomials,
+
+vel_coeff[i]=T'(tc).
+              i
+
+   Evaluating these polynomials is a little expensive,  and we don't want
+to evaluate any more than we have to.  (Some planets require many more
+Chebyshev polynomials than others.)  So if 'tc' is unchanged,  we can
+rest assured that 'n_posn_avail' Chebyshev polynomials,  and 'n_vel_avail'
+derivatives of Chebyshev polynomials,  have already been evaluated,  and
+we start from there,  using the recurrence formulae
+
+T (x) = 1      T (x) = x      T   (x) = 2xT (x) - T   (x)
+ 0              1              n+1         n       n-1
+
+T'(x) = 0      T'(x) = 1      T'  (x) = 2xT'(x) + 2T (x) - T'   (x)
+ 0              1              n+1         n        n        n-1
+
+   (the second set being just the derivatives of the first).  To get the
+_acceleration_ of an object,  we just keep going and get the second
+derivatives as
+
+T"(x) = 0      T"(x) = 1      T"  (x) = 2xT"(x) + 4T'(x) - T"   (x)
+ 0              1              n+1         n        n        n-1
+
+   At present, i can range from 0 to 17.  If future JPL ephems require
+Chebyshev polynomials beyond T  ,  those arrays may need to be expanded.
+                              17                                            */
+
+/*****************************************************************************
+**                     interp(buf,t,ncf,ncm,na,ifl,pv)                      **
+******************************************************************************
+**                                                                          **
+**    this subroutine differentiates and interpolates a                     **
+**    set of chebyshev coefficients to give position and velocity           **
+**                                                                          **
+**    calling sequence parameters:                                          **
+**                                                                          **
+**      input:                                                              **
+**                                                                          **
+**      iinfo   stores certain chunks of interpolation info,  in hopes      **
+**              that if you call again with similar parameters,  the        **
+**              function won't have to re-compute all coefficients/data.    **
+**                                                                          **
+**       coef   1st location of array of d.p. chebyshev coefficients        **
+**              of position                                                 **
+**                                                                          **
+**          t   t[0] is double fractional time in interval covered by       **
+**              coefficients at which interpolation is wanted               **
+**              (0 <= t[0] <= 1).  t[1] is dp length of whole               **
+**              interval in input time units.                               **
+**                                                                          **
+**        ncf   # of coefficients per component                             **
+**                                                                          **
+**        ncm   # of components per set of coefficients                     **
+**                                                                          **
+**         na   # of sets of coefficients in full array                     **
+**              (i.e., # of sub-intervals in full interval)                 **
+**                                                                          **
+**         ifl  integer flag: =1 for positions only                         **
+**                            =2 for pos and vel                            **
+**                            =3 for pos, vel, accel (currently used for    **
+**                               pvsun only)                                **
+**                                                                          **
+**      output:                                                             **
+**                                                                          **
+**    posvel   interpolated quantities requested.  dimension                **
+**              expected is posvel[ncm*ifl], double precision.              **
+**                                                                          **
+*****************************************************************************/
+static void interp(struct interpolation_info *iinfo,
+        const double coef[], const double t[2], const unsigned ncf, const unsigned ncm,
+        const unsigned na, const int velocity_flag, double posvel[])
+{
+    const double dna = (double)na;
+    const double temp = dna * t[0];
+    unsigned l = (unsigned)temp;
+    double vfac, unused_temp1;
+    double tc = 2.0 * modf(temp, &unused_temp1) - 1.0;
+    unsigned i, j;
+
+    assert(ncf < MAX_CHEBY);
+    if(l == na)
+    {
+      l--;
+      tc = 1.;
+    }
+    assert(tc >= -1.);
+    assert(tc <=  1.);
+
+/*  check to see whether chebyshev time has changed,  and compute new
+    polynomial values if it has.
+    (the element iinfo->posn_coeff[1] is the value of t1[tc] and hence
+    contains the value of tc on the previous call.)     */
+
+
+    if(tc != iinfo->posn_coeff[1])
+    {
+      iinfo->n_posn_avail = 2;
+      iinfo->n_vel_avail = 2;
+      iinfo->posn_coeff[1] = tc;
+      iinfo->twot = tc+tc;
+    }
+
+/*  be sure that at least 'ncf' polynomials have been evaluated and are
+    stored in the array 'iinfo->posn_coeff'.  Note that we start out with
+    posn_coeff[0] = 1. and posn_coeff[1] = tc (see 'jpl_init_ephemeris'
+    below),  and vel_coeff[0] and [1] are similarly preset.  We do that
+    because you need the first two coeffs of those series to start the
+    Chebyshev recurrence;  see the comments above this function.   */
+
+    if(iinfo->n_posn_avail < ncf)
+    {
+      double *pc_ptr = iinfo->posn_coeff + iinfo->n_posn_avail;
+
+      for(i=ncf - iinfo->n_posn_avail; i; i--, pc_ptr++)
+         *pc_ptr = iinfo->twot * pc_ptr[-1] - pc_ptr[-2];
+      iinfo->n_posn_avail=ncf;
+    }
+
+/*  interpolate to get position for each component  */
+
+    for(i = 0; i < ncm; ++i)        /* ncm is a number of coordinates */
+    {
+      const double *coeff_ptr = coef + ncf * (i + l * ncm + 1);
+      const double *pc_ptr = iinfo->posn_coeff + ncf;
+
+      *posvel = 0.0;
+      for(j = ncf; j; j--)
+         *posvel += (*--pc_ptr) * (*--coeff_ptr);
+      posvel++;
+    }
+
+    if(velocity_flag <= 1) return;
+
+/*  if velocity interpolation is wanted, be sure enough
+    derivative polynomials have been generated and stored.    */
+
+    if(iinfo->n_vel_avail < ncf)
+    {
+      double *vc_ptr = iinfo->vel_coeff + iinfo->n_vel_avail;
+      const double *pc_ptr = iinfo->posn_coeff + iinfo->n_vel_avail - 1;
+
+      for(i = ncf - iinfo->n_vel_avail; i; i--, vc_ptr++, pc_ptr++)
+         *vc_ptr = iinfo->twot * vc_ptr[-1] + *pc_ptr + *pc_ptr - vc_ptr[-2];
+      iinfo->n_vel_avail = ncf;
+    }
+
+/*  interpolate to get velocity for each component    */
+
+    vfac = (dna + dna) / t[1];
+    for(i = 0; i < ncm; ++i)
+    {
+      double tval = 0.;
+      const double *coeff_ptr = coef + ncf * (i + l * ncm + 1);
+      const double *vc_ptr = iinfo->vel_coeff + ncf;
+
+      for(j = ncf - 1; j; j--)
+         tval += (*--vc_ptr) * (*--coeff_ptr);
+      *posvel++ = tval * vfac;
+    }
+
+            /* Accelerations are rarely computed -- at present,  only */
+            /* for pvsun -- so we don't get so tricky in optimizing.  */
+            /* The accel_coeffs (the second derivative of the Chebyshev */
+            /* polynomials) are not stored for repeated use,  for example. */
+    if(velocity_flag == 3)
+    {
+
+      double accel_coeffs[MAX_CHEBY];
+
+      accel_coeffs[0] = accel_coeffs[1] = 0.;
+      for(i = 2; i < ncf; i++)              /* recurrence for T"(x) */
+         accel_coeffs[i] = 4. * iinfo->vel_coeff[i - 1]
+                        + iinfo->twot * accel_coeffs[i - 1]
+                        - accel_coeffs[i - 2];
+
+      for(i = 0; i < ncm; ++i)        /* ncm is a number of coordinates */
+      {
+         double tval = 0.;
+         const double *coeff_ptr = coef + ncf * (i + l * ncm + 1);
+         const double *ac_ptr = accel_coeffs + ncf;
+
+         for(j = ncf; j; j--)
+            tval += (*--ac_ptr) * (*--coeff_ptr);
+         *posvel++ = tval * vfac * vfac;
+      }
+    }
+    
+    return;
+}
+
+/* swap_32_bit_val() and swap_64_bit_val() are used when reading a binary
+ephemeris that was created on a machine with 'opposite' byte order to
+the currently-used machine (signalled by the 'swap_bytes' flag in the
+jpl_eph_data structure).  In such cases,  every double and integer
+value read from the ephemeris must be byte-swapped by these two functions. */
+
+#define SWAP_MACRO(A, B, TEMP)   { TEMP = A;  A = B;  B = TEMP; }
+
+static void swap_32_bit_val(void *ptr)
+{
+    char *tptr = (char *)ptr, tchar;
+
+   SWAP_MACRO(tptr[0], tptr[3], tchar);
+   SWAP_MACRO(tptr[1], tptr[2], tchar);
+}
+
+static void swap_64_bit_val(void *ptr, long count)
+{
+    char *tptr = (char *)ptr, tchar;
+    
+    while(count--)
+    {
+      SWAP_MACRO(tptr[0], tptr[7], tchar);
+      SWAP_MACRO(tptr[1], tptr[6], tchar);
+      SWAP_MACRO(tptr[2], tptr[5], tchar);
+      SWAP_MACRO(tptr[3], tptr[4], tchar);
+
+      tptr += 8;
+    }
+}
+
+/* Most ephemeris quantities have a dimension of three.  Planet positions
+have an x, y, and z;  librations and lunar mantle angles have three Euler
+angles.  But TDT-TT is a single quantity,  and nutation is expressed as
+two angles.   */
+
+static int dimension(const int idx)
+{
+    int rval;
+
+    if(idx == 11)             /* Nutations */
+      rval = 2;
+    else if(idx == 14)        /* TDT - TT */
+      rval = 1;
+    else                       /* planets, lunar mantle angles, librations */
+      rval = 3;
+    return(rval);
+}
+
+/*****************************************************************************
+**                        jpl_state(ephem,et2,list,pv,nut,bary)             **
+******************************************************************************
+** This subroutine reads and interpolates the jpl planetary ephemeris file  **
+**                                                                          **
+**    Calling sequence parameters:                                          **
+**                                                                          **
+**    Input:                                                                **
+**                                                                          **
+**        et2[] double, 2-element JED epoch at which interpolation          **
+**              is wanted.  Any combination of et2[0]+et2[1] which falls    **
+**              within the time span on the file is a permissible epoch.    **
+**                                                                          **
+**               a. for ease in programming, the user may put the           **
+**                  entire epoch in et2[0] and set et2[1]=0.0               **
+**                                                                          **
+**               b. for maximum interpolation accuracy, set et2[0] =        **
+**                  the most recent midnight at or before interpolation     **
+**                  epoch and set et2[1] = fractional part of a day         **
+**                  elapsed between et2[0] and epoch.                       **
+**                                                                          **
+**               c. as an alternative, it may prove convenient to set       **
+**                  et2[0] = some fixed epoch, such as start of integration,**
+**                  and et2[1] = elapsed interval between then and epoch.   **
+**                                                                          **
+**       list   13-element integer array specifying what interpolation      **
+**              is wanted for each of the "bodies" on the file.             **
+**                                                                          **
+**                        list[i]=0, no interpolation for body i            **
+**                               =1, position only                          **
+**                               =2, position and velocity                  **
+**                                                                          **
+**              the designation of the astronomical bodies by i is:         **
+**                                                                          **
+**                        i = 0: mercury                                    **
+**                          = 1: venus                                      **
+**                          = 2: earth-moon barycenter                      **
+**                          = 3: mars                                       **
+**                          = 4: jupiter                                    **
+**                          = 5: saturn                                     **
+**                          = 6: uranus                                     **
+**                          = 7: neptune                                    **
+**                          = 8: pluto                                      **
+**                          = 9: geocentric moon                            **
+**                          =10: nutations in lon & obliq (if on file)      **
+**                          =11: lunar librations (if on file)              **
+**                          =12: lunar mantle omegas                        **
+**                          =13: TT-TDB (if on file)                        **
+**                                                                          **
+** Note that I've not actually seen case 12 yet.  It probably doesn't work. **
+**                                                                          **
+**    output:                                                               **
+**                                                                          **
+**    pv[][6]   double array that will contain requested interpolated       **
+**              quantities.  The body specified by list[i] will have its    **
+**              state in the array starting at pv[i][0]  (on any given      **
+**              call, only those words in 'pv' which are affected by the    **
+**              first 10 'list' entries (and by list(11) if librations are  **
+**              on the file) are set.  The rest of the 'pv' array           **
+**              is untouched.)  The order of components in pv[][] is:       **
+**              pv[][0]=x,....pv[][5]=dz.                                   **
+**                                                                          **
+**              All output vectors are referenced to the earth mean         **
+**              equator and equinox of epoch. The moon state is always      **
+**              geocentric; the other nine states are either heliocentric   **
+**              or solar-system barycentric, depending on the setting of    **
+**              global variables (see below).                               **
+**                                                                          **
+**              Lunar librations, if on file, are put into pv[10][k] if     **
+**              list[11] is 1 or 2.                                         **
+**                                                                          **
+**        nut   dp 4-word array that will contain nutations and rates,      **
+**              depending on the setting of list[10].  the order of         **
+**              quantities in nut is:                                       **
+**                                                                          **
+**                       d psi  (nutation in longitude)                     **
+**                       d epsilon (nutation in obliquity)                  **
+**                       d psi dot                                          **
+**                       d epsilon dot                                      **
+**                                                                          **
+*****************************************************************************/
+int DLL_FUNC jpl_state(void *ephem, const double et, const int list[14],
+                          double pv[][6], double nut[4], const int bary)
+{
+  struct jpl_eph_data *eph = (struct jpl_eph_data *)ephem;
+  unsigned i, j, n_intervals;
+  uint32_t nr;
+  double *buf = eph->cache;
+  double t[2];
+  const double block_loc = (et - eph->ephem_start) / eph->ephem_step;
+  bool recompute_pvsun;
+  const double aufac = 1.0 / eph->au;
+
+/*   error return for epoch out of range  */
+  if(et < eph->ephem_start || et > eph->ephem_end)
+    return(JPL_EPH_OUTSIDE_RANGE);
+
+/*   calculate record # and relative time in interval   */
+
+  nr = (uint32_t)block_loc;
+  t[0] = block_loc - (double)nr;
+  if(!t[0] && nr)
+  {
+    t[0] = 1.;
+    nr--;
+  }  
+
+/*   read correct record if not in core (static vector buf[])   */
+    if(nr != eph->curr_cache_loc)
+    {
+      eph->curr_cache_loc = nr;
+                  /* Read two blocks ahead to account for header: */
+      if(FSeek(eph->ifile, (nr + 2) * eph->recsize, SEEK_SET))
+      {
+	      // GZ: Make sure we will try again on next call...
+	      eph->curr_cache_loc=0;
+	      return(JPL_EPH_FSEEK_ERROR);
+      }
+      if(fread(buf, sizeof(double), (size_t)eph->ncoeff, eph->ifile)
+                               != (size_t)eph->ncoeff)
+        return(JPL_EPH_READ_ERROR);
+
+      if(eph->swap_bytes)
+         swap_64_bit_val(buf, eph->ncoeff);
+      }
+    t[1] = eph->ephem_step;
+
+    if(eph->pvsun_t != et)   /* If several calls are made for the same et, */
+    {                      /* don't recompute pvsun each time... only on */
+      recompute_pvsun = true;   /* the first run through.                     */
+      eph->pvsun_t = et;
+    }
+    else
+      recompute_pvsun = false;
+
+          /* Here, i loops through the "traditional" 14 listed items -- 10
+          solar system objects,  nutations,  librations,  lunar mantle angles,
+          and TT-TDT -- plus a fifteenth:  the solar system barycenter.  That
+          last is quite different:  it's computed 'as needed',  rather than
+          from list[];  the output goes to pvsun rather than the pv array;
+          and three quantities (position,  velocity,  acceleration) are
+          computed (nobody else gets accelerations at present.)  */
+  for(n_intervals = 1; n_intervals <= 8; n_intervals *= 2)
+    for(i = 0; i < 15; i++)
+    {
+        unsigned quantities;
+        uint32_t *iptr = &eph->ipt[i + 1][0];
+
+        if(i == 14)
+        {
+            quantities = (recompute_pvsun ? 3 : 0);
+            iptr = &eph->ipt[10][0];
+          }
+          else
+          {
+            quantities = list[i];
+            iptr = &eph->ipt[i < 10 ? i : i + 1][0];
+          }
+          if(n_intervals == iptr[2] && quantities)
+          {
+            double *dest = ((i == 10) ? eph->pvsun : pv[i]);
+
+            if(i < 10)
+               dest = pv[i];
+            else if(i == 14)
+               dest = eph->pvsun;
+            else
+               dest = nut;
+            interp(&eph->iinfo, &buf[iptr[0]-1], t, (int)iptr[1],
+                                    dimension(i + 1),
+                                    n_intervals, quantities, dest);
+
+            if(i < 10 || i == 14)        /*  convert km to AU */
+               for(j = 0; j < quantities * 3; j++)
+                  dest[j] *= aufac;
+            }
+         }
+    if(!bary)                             /* gotta correct everybody for */
+      for(i = 0; i < 9; i++)            /* the solar system barycenter */
+         for(j = 0; j < (unsigned)list[i] * 3; j++)
+            pv[i][j] -= eph->pvsun[j];
+    return(0);
+}
+
+static int init_err_code = JPL_INIT_NOT_CALLED;
+
+int DLL_FUNC jpl_init_error_code(void)
+{
+   return(init_err_code);
+}
+
+const char * jpl_init_error_message(void)
+{
+  switch(init_err_code)
+  {
+    case 0:
+      return (const char *)("JPL_INIT_NO_ERROR");
+    case -1:
+      return (const char *)("JPL_INIT_FILE_NOT_FOUND");
+    case -2:
+      return (const char *)("JPL_INIT_FSEEK_FAILED");    
+    case -3:
+      return (const char *)("JPL_INIT_FREAD_FAILED");
+    case -4:
+      return (const char *)("JPL_INIT_FREAD2_FAILED");
+    case -5:
+      return (const char *)("JPL_INIT_FILE_CORRUPT");
+    case -6:
+      return (const char *)("JPL_INIT_MEMORY_FAILURE");
+    case -7:
+      return (const char *)("JPL_INIT_FREAD3_FAILED");
+    case -8:
+      return (const char *)("JPL_INIT_FREAD4_FAILED");
+    case -9:
+      return (const char *)("JPL_INIT_NOT_CALLED");
+    case -10:
+      return (const char *)("JPL_INIT_FREAD5_FAILED");
+    default:
+      return (const char *)("ERROR_NOT_RECOGNIZED");
+  }
+}
+
+   /* DE-430 has 572 constants.  That's more than the 400 constants */
+   /* originally expected.  The remaining 172 are stored after the  */
+   /* other header data :                                           */
+
+#define START_400TH_CONSTANT_NAME   (84 * 3 + 400 * 6 + 5 * sizeof(double) \
+                                                    + 41 * sizeof(int32_t))
+
+   /* ...which comes out to 2856.  See comments in 'jpl_int.h'.   */
+
+/****************************************************************************
+**    jpl_init_ephemeris(ephemeris_filename, nam, val, n_constants)       **
+*****************************************************************************
+**                                                                         **
+**    this function does the initial prep work for use of binary JPL       **
+**    ephemerides.                                                         **
+**      const char *ephemeris_filename = full path/filename of the binary  **
+**          ephemeris (on the Willmann-Bell CDs,  this is UNIX.200, 405,   **
+**          or 406)                                                        **
+**      char nam[][6] = array of constant names (max 6 characters each)    **
+**          You can pass nam=NULL if you don't care about the names        **
+**      double *val = array of values of constants                         **
+**          You can pass val=NULL if you don't care about the constants    **
+**      Return value is a pointer to the jpl_eph_data structure            **
+**      NULL is returned if the file isn't opened or memory isn't alloced  **
+**      Errors can be determined with the above jpl_init_error_code()     **
+****************************************************************************/
+
+void * DLL_FUNC jpl_init_ephemeris(const char *ephemeris_filename,
+                          char nam[][6], double *val)
+{
+    unsigned i, j;
+    long de_version;
+    char title[84];
+    FILE *ifile = fopen(ephemeris_filename, "rb");
+
+    struct jpl_eph_data *rval;
+    struct jpl_eph_data temp_data;
+
+    init_err_code = 0;
+    temp_data.ifile = ifile;
+    if(!ifile)
+      init_err_code = JPL_INIT_FILE_NOT_FOUND;
+    else if(fread(title, 84, 1, ifile) != 1)
+      init_err_code = JPL_INIT_FREAD_FAILED;
+    else if(FSeek(ifile, 2652L, SEEK_SET))
+      init_err_code = JPL_INIT_FSEEK_FAILED;
+    else if(fread(&temp_data, JPL_HEADER_SIZE, 1, ifile) != 1)
+      init_err_code = JPL_INIT_FREAD2_FAILED;
+
+    if(init_err_code)
+    {
+      if(ifile)
+        fclose(ifile);
+      return(NULL);
+    }
+
+    de_version = atoi(title + 26);
+    
+    /* A small piece of trickery:  in the binary file,  data is stored */
+    /* for ipt[0...11],  then the ephemeris version,  then the         */
+    /* remaining ipt[12] data.  A little switching is required to get  */
+    /* the correct order. */
+    temp_data.ipt[12][0] = temp_data.ipt[12][1];
+    temp_data.ipt[12][1] = temp_data.ipt[12][2];
+    temp_data.ipt[12][2] = temp_data.ipt[13][0];
+    temp_data.ephemeris_version = de_version;
+
+    //qDebug() << "DE_Version: " << de_version;
+
+
+    temp_data.swap_bytes = (temp_data.ncon > 65536L);
+    if(temp_data.swap_bytes)     /* byte order is wrong for current platform */
+    {
+      qDebug() << "Byte order is wrong for current platform";
+      
+      swap_64_bit_val(&temp_data.ephem_start, 1);
+      swap_64_bit_val(&temp_data.ephem_end, 1);
+      swap_64_bit_val(&temp_data.ephem_step, 1);
+      swap_32_bit_val(&temp_data.ncon);
+      swap_64_bit_val(&temp_data.au, 1);
+      swap_64_bit_val(&temp_data.emrat, 1);
+    }
+
+            /* It's a little tricky to tell if an ephemeris really has  */
+            /* TT-TDB data (with offsets in ipt[13][] and ipt[14][]).   */
+            /* Essentially,  we read the data and sanity-check it,  and */
+            /* zero it if it "doesn't add up" correctly.                */
+            /*    Also:  certain ephems I've generated with ncon capped */
+            /* at 400 have no TT-TDB data.  So if ncon == 400,  don't   */
+            /* try to read such data;  you may get garbage.             */
+    if(de_version >= 430 && temp_data.ncon != 400)
+    {
+         /* If there are 400 or fewer constants,  data for ipt[13][0...2] */
+         /* immediately follows that for ipt[12][0..2];  i.e.,  we don't  */
+         /* need to fseek().  Otherwise,  we gotta skip 6*(n_constants-400) */
+         /* bytes. */
+      if(temp_data.ncon > 400)
+	 FSeek(ifile, (size_t)(temp_data.ncon - 400) * 6, SEEK_CUR);
+      if(fread(&temp_data.ipt[13][0], sizeof(int32_t), 6, ifile) != 6)
+         init_err_code = JPL_INIT_FREAD5_FAILED;
+    }
+    else                 /* mark header data as invalid */
+      temp_data.ipt[13][0] = (uint32_t)-1;
+
+    if(temp_data.swap_bytes)     /* byte order is wrong for current platform */
+    {  
+        for(j = 0; j < 3; j++)
+        {
+            for(i = 0; i < 15; i++)
+            { 
+                swap_32_bit_val(&temp_data.ipt[i][j]);
+            }
+        }
+    }
+
+    if(temp_data.ipt[13][0] !=       /* if these don't add up correctly, */
+          temp_data.ipt[12][0] + temp_data.ipt[12][1] * temp_data.ipt[12][2] * 3
+    || temp_data.ipt[14][0] !=       /* zero them out (they've garbage data) */
+          temp_data.ipt[13][0] + temp_data.ipt[13][1] * temp_data.ipt[13][2] * 3)
+    {     /* not valid pointers to TT-TDB data */
+      memset(&temp_data.ipt[13][0], 0, 6 * sizeof(int32_t));
+    }
+
+         /* A sanity check:  if the earth-moon ratio is outside reasonable */
+         /* bounds,  we must be looking at a wrong or corrupted file.      */
+         /* In DE-102,  emrat = 81.3007;  in DE-405/406, emrat = 81.30056. */
+         /* Those are the low and high ranges.  We'll allow some slop in   */
+         /* case the earth/moon mass ratio changes:                        */
+    if(temp_data.emrat > 81.3008 || temp_data.emrat < 81.30055)
+    {   
+      init_err_code = JPL_INIT_FILE_CORRUPT;
+      qWarning() << "temp_data: " << temp_data.emrat << "(should have been =~81). JPL_INIT_FILE_CORRUPT!";
+    }
+
+    if(init_err_code)
+    {
+      fclose(ifile);
+      return(NULL);
+    }
+
+         /* Once upon a time,  the kernel size was determined from the */
+         /* DE version.  This was not a terrible idea,  except that it */
+         /* meant that when the code faced a new version,  it broke.   */
+         /* Now we use some logic to compute the kernel size.          */
+    temp_data.kernel_size = 4;
+    for(i = 0; i < 15; i++)
+      temp_data.kernel_size +=
+             2 * temp_data.ipt[i][1] * temp_data.ipt[i][2] * dimension(i);
+// for(i = 0; i < 13; i++)
+//    temp_data.kernel_size +=
+//                     temp_data.ipt[i][1] * temp_data.ipt[i][2] * ((i == 11) ? 4 : 6);
+//       /* ...and then add in space required for the TT-TDB data : */
+// temp_data.kernel_size += temp_data.ipt[14][1] * temp_data.ipt[14][2] * 2;
+    temp_data.recsize = temp_data.kernel_size * 4L;
+    temp_data.ncoeff = temp_data.kernel_size / 2L;
+
+               /* Rather than do two separate allocations,  everything     */
+               /* we need is allocated in _one_ chunk,  then parceled out. */
+               /* This looks a little weird,  but it simplifies error      */
+               /* handling and cleanup.                                    */
+    rval = (struct jpl_eph_data *)calloc(sizeof(struct jpl_eph_data)
+                        + temp_data.recsize, 1);
+    if(!rval)
+    {
+      init_err_code = JPL_INIT_MEMORY_FAILURE;
+      fclose(ifile);
+      return(NULL);
+    }
+    memcpy(rval, &temp_data, sizeof(struct jpl_eph_data));
+    rval->iinfo.posn_coeff[0] = 1.0;
+            /* Seed a bogus value here.  The first and subsequent calls to */
+            /* 'interp' will correct it to a value between -1 and +1.      */
+    rval->iinfo.posn_coeff[1] = -2.0;
+    rval->iinfo.vel_coeff[0] = 0.0;
+    rval->iinfo.vel_coeff[1] = 1.0;
+    rval->curr_cache_loc = (uint32_t)-1;
+    
+              /* The 'cache' data is right after the 'jpl_eph_data' struct: */
+    rval->cache = (double *)(rval + 1);
+               /* If there are more than 400 constants,  the names of       */
+               /* the extra constants are stored in what would normally     */
+               /* be zero-padding after the header record.  However,        */
+               /* older ephemeris-reading software won't know about that.   */
+               /* So we store ncon=400,  then actually check the names to   */
+               /* see how many constants there _really_ are.  Older readers */
+               /* will just see 400 names and won't know about the others.  */
+               /* But on the upside, they won't crash.                      */
+
+    if(rval->ncon == 400)
+    {
+      char buff[7];
+
+      buff[6] = '\0';
+      FSeek(ifile, START_400TH_CONSTANT_NAME, SEEK_SET);
+      while(fread(buff, 6, 1, ifile) && strlen(buff) == 6)
+      {
+         rval->ncon++;
+      }
+    }
+
+    if(val)
+    {
+      FSeek(ifile, rval->recsize, SEEK_SET);
+      if(fread(val, sizeof(double), (size_t)rval->ncon, ifile)
+                        != (size_t)rval->ncon)
+         init_err_code = JPL_INIT_FREAD3_FAILED;
+      else if(rval->swap_bytes)     /* gotta swap the constants,  too */
+         swap_64_bit_val(val, rval->ncon);
+      }
+
+   if(!init_err_code && nam)
+      {
+      FSeek(ifile, 84L * 3L, SEEK_SET);   /* just after the 3 'title' lines */
+      for(i = 0; i < rval->ncon && !init_err_code; i++)
+      {
+        if(i == 400)
+	  FSeek(ifile, START_400TH_CONSTANT_NAME, SEEK_SET);
+        if(fread(nam[i], 6, 1, ifile) != 1)
+          init_err_code = JPL_INIT_FREAD4_FAILED;
+        }
+      }
+  return(rval);
+}
+
+/****************************************************************************
+**    jpl_close_ephemeris(ephem)                                          **
+*****************************************************************************
+**                                                                         **
+**    this function closes files and frees up memory allocated by the      **
+**    jpl_init_ephemeris() function.                                      **
+****************************************************************************/
+void DLL_FUNC jpl_close_ephemeris(void *ephem)
+{
+   struct jpl_eph_data *eph = (struct jpl_eph_data *)ephem;
+
+   fclose(eph->ifile);
+   free(ephem);
+}
+
+/* Added 2011 Jan 18:  random access to any desired JPL constant */
+
+
+double DLL_FUNC jpl_get_constant(const int idx, void *ephem, char *constant_name)
+{
+   struct jpl_eph_data *eph = (struct jpl_eph_data *)ephem;
+   double rval = 0.;
+
+   *constant_name = '\0';
+   if(idx >= 0 && idx < (int)eph->ncon)
+      {
+	   // GZ extended from const long to const long long
+      const long long seek_loc = (idx < 400 ? 84L * 3L + (long)idx * 6 :
+                      START_400TH_CONSTANT_NAME + (idx - 400) * 6);
+
+      FSeek(eph->ifile, seek_loc, SEEK_SET);
+      if(fread(constant_name, 1, 6, eph->ifile))
+         {
+         constant_name[6] = '\0';
+	 FSeek(eph->ifile, eph->recsize + (long)idx * sizeof(double), SEEK_SET);
+         if(fread(&rval, 1, sizeof(double), eph->ifile))
+            if(eph->swap_bytes)     /* gotta swap the constants,  too */
+               swap_64_bit_val(&rval, 1);
+         }
+      }
+   return(rval);
+}
+/*************************** THE END ***************************************/
 
=== added file 'src/core/planetsephems/jpleph.h'
--- src/core/planetsephems/jpleph.h	1970-01-01 00:00:00 +0000
+++ src/core/planetsephems/jpleph.h	2016-01-16 17:00:50 +0000
@@ -0,0 +1,117 @@
+/* jpleph.h: header for JPL ephemeris functions
+
+Copyright (C) 2011, Project Pluto
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.    */
+
+/***************************************************************************
+*******                  JPLEPH.H                                  *********
+****************************************************************************
+**  This header file is used both by ASC2EPH and TESTEPH programs.        **
+****************************************************************************
+**  Written: May 28, 1997 by PAD   **  Last modified: June 23,1997 by PAD **
+**  Modified further by Bill Gray,  Jun-Aug 2001                          **
+****************************************************************************
+**  PAD: dr. Piotr A. Dybczynski,          e-mail: [e-mail]  **
+**   Astronomical Observatory of the A.Mickiewicz Univ., Poznan, Poland   **
+***************************************************************************/
+
+/* By default,  in Windoze 32,  the JPL ephemeris functions are compiled
+   into a DLL.  This is not really all that helpful at present,  but may
+   be useful to people who want to use the functions from languages other
+   than C. */
+
+#ifdef _WIN32
+#define DLL_FUNC __stdcall
+#else
+#define DLL_FUNC
+#endif
+
+#ifdef __WATCOMC__
+   #include <stdbool.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void * DLL_FUNC jpl_init_ephemeris( const char *ephemeris_filename,
+                                             char nam[][6], double *val);
+void DLL_FUNC jpl_close_ephemeris( void *ephem);
+int DLL_FUNC jpl_state( void *ephem, const double et, const int list[14],
+                          double pv[][6], double nut[4], const int bary);
+int DLL_FUNC jpl_pleph( void *ephem, const double et, const int ntarg,
+                      const int ncent, double rrd[], const int calc_velocity);
+double DLL_FUNC jpl_get_double( const void *ephem, const int value);
+long DLL_FUNC jpl_get_long( const void *ephem, const int value);
+int DLL_FUNC make_sub_ephem( void *ephem, const char *sub_filename,
+                              const double start_jd, const double end_jd);
+double DLL_FUNC jpl_get_constant( const int idx, void *ephem, char *constant_name);
+
+#ifdef __cplusplus
+}
+#endif
+
+         /* Following are constants used in          */
+         /* jpl_get_double( ) and jpl_get_long( ):   */
+
+#define JPL_EPHEM_START_JD               0
+#define JPL_EPHEM_END_JD                 8
+#define JPL_EPHEM_STEP                  16
+#define JPL_EPHEM_N_CONSTANTS           24
+#define JPL_EPHEM_AU_IN_KM              28
+#define JPL_EPHEM_EARTH_MOON_RATIO      36
+#define JPL_EPHEM_IPT_ARRAY             44
+#define JPL_EPHEM_EPHEMERIS_VERSION    224
+#define JPL_EPHEM_KERNEL_SIZE          228
+#define JPL_EPHEM_KERNEL_RECORD_SIZE   232
+#define JPL_EPHEM_KERNEL_NCOEFF        236
+#define JPL_EPHEM_KERNEL_SWAP_BYTES    240
+
+         /* The following error codes may be returned by */
+         /* jpl_state() and jpl_pleph():                 */
+#define JPL_EPH_OUTSIDE_RANGE                (-1)
+#define JPL_EPH_READ_ERROR                   (-2)
+#define JPL_EPH_QUANTITY_NOT_IN_EPHEMERIS    (-3)
+#define JPL_EPH_INVALID_INDEX                (-5)
+#define JPL_EPH_FSEEK_ERROR                  (-6)
+
+int DLL_FUNC jpl_init_error_code( void);
+
+         /* The following error codes may be returned by       */
+         /* jpl_init_error_code( ) after jpl_init_ephemeris( ) */
+         /* has been called:                                   */
+
+#define JPL_INIT_NO_ERROR                 0
+#define JPL_INIT_FILE_NOT_FOUND          -1
+#define JPL_INIT_FSEEK_FAILED            -2
+#define JPL_INIT_FREAD_FAILED            -3
+#define JPL_INIT_FREAD2_FAILED           -4
+#define JPL_INIT_FREAD5_FAILED           -10
+#define JPL_INIT_FILE_CORRUPT            -5
+#define JPL_INIT_MEMORY_FAILURE          -6
+#define JPL_INIT_FREAD3_FAILED           -7
+#define JPL_INIT_FREAD4_FAILED           -8
+#define JPL_INIT_NOT_CALLED              -9
+
+#define jpl_get_pvsun( ephem) ((double *)((char *)ephem + 248))
+
+/* addition for use in stellarium */
+#define JPL_MAX_N_CONSTANTS 1018
+#define CALC_VELOCITY       0
+#define CENTRAL_PLANET_ID   11  //ID of sun in JPL enumeration
+
+const char * jpl_init_error_message(void);
 
=== modified file 'src/core/planetsephems/pluto.h'
--- src/core/planetsephems/pluto.h	2013-08-04 14:59:29 +0000
+++ src/core/planetsephems/pluto.h	2016-01-16 17:00:50 +0000
@@ -20,6 +20,11 @@
 #ifndef LN_PLUTO_H
 #define LN_PLUTO_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 struct pluto_argument
 {
 	double J, S, P;
@@ -40,5 +45,11 @@
 	double A,B;
 };
 
+void get_pluto_helio_coords (double JD, double * X, double * Y, double * Z);
+
+#ifdef __cplusplus
+}
+#endif
+
 
 #endif
 
=== removed file 'src/core/planetsephems/stellplanet.c'
--- src/core/planetsephems/stellplanet.c	2013-08-04 14:59:29 +0000
+++ src/core/planetsephems/stellplanet.c	1970-01-01 00:00:00 +0000
@@ -1,136 +0,0 @@
-/*
-Copyright (C) 2003 Fabien Chereau
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU Library General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
-*/
-
-#include "vsop87.h"
-#include "elp82b.h"
-#include "marssat.h"
-#include "l1.h"
-#include "tass17.h"
-#include "gust86.h"
-
-/* Chapter 31 Pg 206-207 Equ 31.1 31.2 , 31.3 using VSOP 87
- * Calculate planets rectangular heliocentric ecliptical coordinates
- * for given julian day. Values are in AU.
- * params : Julian day, rect coords */
-void get_pluto_helio_coords(double jd, double * X, double * Y, double * Z);
-
-void get_pluto_helio_coordsv(double jd,double xyz[3], void* unused)
-  {get_pluto_helio_coords(jd, &xyz[0], &xyz[1], &xyz[2]);}
-
-
-/* Return 0 of course... */
-void get_sun_helio_coordsv(double jd,double xyz[3], void* unused)
-  {xyz[0]=0.; xyz[1]=0.; xyz[2]=0.;}
-
-void get_mercury_helio_coordsv(double jd,double xyz[3], void* unused)
-  {GetVsop87Coor(jd,VSOP87_MERCURY,xyz);}
-void get_venus_helio_coordsv(double jd,double xyz[3], void* unused)
-  {GetVsop87Coor(jd,VSOP87_VENUS,xyz);}
-
-void get_earth_helio_coordsv(const double jd,double xyz[3]) {
-  double moon[3];
-  GetVsop87Coor(jd,VSOP87_EMB,xyz);
-  GetElp82bCoor(jd,moon);
-    /* Earth != EMB:
-       0.0121505677733761 = mu_m/(1+mu_m),
-       mu_m = mass(moon)/mass(earth) = 0.01230002 */
-  xyz[0] -= 0.0121505677733761 * moon[0];
-  xyz[1] -= 0.0121505677733761 * moon[1];
-  xyz[2] -= 0.0121505677733761 * moon[2];
-}
-
-void get_mars_helio_coordsv(double jd,double xyz[3], void* unused)
-  {GetVsop87Coor(jd,VSOP87_MARS,xyz);}
-void get_jupiter_helio_coordsv(double jd,double xyz[3], void* unused)
-  {GetVsop87Coor(jd,VSOP87_JUPITER,xyz);}
-void get_saturn_helio_coordsv(double jd,double xyz[3], void* unused)
-  {GetVsop87Coor(jd,VSOP87_SATURN,xyz);}
-void get_uranus_helio_coordsv(double jd,double xyz[3], void* unused)
-  {GetVsop87Coor(jd,VSOP87_URANUS,xyz);}
-void get_neptune_helio_coordsv(double jd,double xyz[3], void* unused)
-  {GetVsop87Coor(jd,VSOP87_NEPTUNE,xyz);}
-
-void get_mercury_helio_osculating_coords(double jd0,double jd,double xyz[3])
-  {GetVsop87OsculatingCoor(jd0,jd,VSOP87_MERCURY,xyz);}
-void get_venus_helio_osculating_coords(double jd0,double jd,double xyz[3])
-  {GetVsop87OsculatingCoor(jd0,jd,VSOP87_VENUS,xyz);}
-void get_earth_helio_osculating_coords(double jd0,double jd,double xyz[3])
-  {GetVsop87OsculatingCoor(jd0,jd,VSOP87_EMB,xyz);}
-void get_mars_helio_osculating_coords(double jd0,double jd,double xyz[3])
-  {GetVsop87OsculatingCoor(jd0,jd,VSOP87_MARS,xyz);}
-void get_jupiter_helio_osculating_coords(double jd0,double jd,double xyz[3])
-  {GetVsop87OsculatingCoor(jd0,jd,VSOP87_JUPITER,xyz);}
-void get_saturn_helio_osculating_coords(double jd0,double jd,double xyz[3])
-  {GetVsop87OsculatingCoor(jd0,jd,VSOP87_SATURN,xyz);}
-void get_uranus_helio_osculating_coords(double jd0,double jd,double xyz[3])
-  {GetVsop87OsculatingCoor(jd0,jd,VSOP87_URANUS,xyz);}
-void get_neptune_helio_osculating_coords(double jd0,double jd,double xyz[3])
-  {GetVsop87OsculatingCoor(jd0,jd,VSOP87_NEPTUNE,xyz);}
-
-/* Calculate the rectangular geocentric lunar coordinates to the inertial mean
- * ecliptic and equinox of J2000.
- * The geocentric coordinates returned are in units of AU.
- * This function is based upon the Lunar Solution ELP2000-82B by
- * Michelle Chapront-Touze and Jean Chapront of the Bureau des Longitudes,
- * Paris. ELP 2000-82B theory
- * param jd Julian day, rect pos */
-void get_lunar_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetElp82bCoor(jd,xyz);}
-
-void get_phobos_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetMarsSatCoor(jd,MARS_SAT_PHOBOS,xyz);}
-void get_deimos_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetMarsSatCoor(jd,MARS_SAT_DEIMOS,xyz);}
-
-void get_io_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetL1Coor(jd,L1_IO,xyz);}
-void get_europa_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetL1Coor(jd,L1_EUROPA,xyz);}
-void get_ganymede_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetL1Coor(jd,L1_GANYMEDE,xyz);}
-void get_callisto_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetL1Coor(jd,L1_CALLISTO,xyz);}
-
-void get_mimas_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetTass17Coor(jd,TASS17_MIMAS,xyz);}
-void get_enceladus_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetTass17Coor(jd,TASS17_ENCELADUS,xyz);}
-void get_tethys_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetTass17Coor(jd,TASS17_TETHYS,xyz);}
-void get_dione_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetTass17Coor(jd,TASS17_DIONE,xyz);}
-void get_rhea_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetTass17Coor(jd,TASS17_RHEA,xyz);}
-void get_titan_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetTass17Coor(jd,TASS17_TITAN,xyz);}
-void get_hyperion_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetTass17Coor(jd,TASS17_HYPERION,xyz);}
-void get_iapetus_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetTass17Coor(jd,TASS17_IAPETUS,xyz);}
-
-void get_miranda_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetGust86Coor(jd,GUST86_MIRANDA,xyz);}
-void get_ariel_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetGust86Coor(jd,GUST86_ARIEL,xyz);}
-void get_umbriel_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetGust86Coor(jd,GUST86_UMBRIEL,xyz);}
-void get_titania_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetGust86Coor(jd,GUST86_TITANIA,xyz);}
-void get_oberon_parent_coordsv(double jd,double xyz[3], void* unused)
-  {GetGust86Coor(jd,GUST86_OBERON,xyz);}
-
 
=== removed file 'src/core/planetsephems/stellplanet.h'
--- src/core/planetsephems/stellplanet.h	2013-08-04 14:59:29 +0000
+++ src/core/planetsephems/stellplanet.h	1970-01-01 00:00:00 +0000
@@ -1,77 +0,0 @@
-/*
-Copyright (C) 2003 Fabien Chereau
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU Library General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
-*/
-
-#ifndef _STELLPLANET_H_
-#define _STELLPLANET_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void get_sun_helio_coordsv(double jd,double xyz[3], void*);
-void get_mercury_helio_coordsv(double jd,double xyz[3], void*);
-void get_venus_helio_coordsv(double jd,double xyz[3], void*);
-void get_earth_helio_coordsv(double jd,double xyz[3], void*);
-void get_mars_helio_coordsv(double jd,double xyz[3], void*);
-void get_jupiter_helio_coordsv(double jd,double xyz[3], void*);
-void get_saturn_helio_coordsv(double jd,double xyz[3], void*);
-void get_uranus_helio_coordsv(double jd,double xyz[3], void*);
-void get_neptune_helio_coordsv(double jd,double xyz[3], void*);
-void get_pluto_helio_coordsv(double jd,double xyz[3], void*);
-
-void get_mercury_helio_osculating_coords(double jd0,double jd,double xyz[3]);
-void get_venus_helio_osculating_coords(double jd0,double jd,double xyz[3]);
-void get_earth_helio_osculating_coords(double jd0,double jd,double xyz[3]);
-void get_mars_helio_osculating_coords(double jd0,double jd,double xyz[3]);
-void get_jupiter_helio_osculating_coords(double jd0,double jd,double xyz[3]);
-void get_saturn_helio_osculating_coords(double jd0,double jd,double xyz[3]);
-void get_uranus_helio_osculating_coords(double jd0,double jd,double xyz[3]);
-void get_neptune_helio_osculating_coords(double jd0,double jd,double xyz[3]);
-void get_pluto_helio_osculating_coords(double jd0,double jd,double xyz[3]);
-
-void get_lunar_parent_coordsv(double jd,double xyz[3], void*);
-
-void get_phobos_parent_coordsv(double jd,double xyz[3], void*);
-void get_deimos_parent_coordsv(double jd,double xyz[3], void*);
-
-void get_io_parent_coordsv(double jd,double xyz[3], void*);
-void get_europa_parent_coordsv(double jd,double xyz[3], void*);
-void get_ganymede_parent_coordsv(double jd,double xyz[3], void*);
-void get_callisto_parent_coordsv(double jd,double xyz[3], void*);
-
-void get_mimas_parent_coordsv(double jd,double xyz[3], void*);
-void get_enceladus_parent_coordsv(double jd,double xyz[3], void*);
-void get_tethys_parent_coordsv(double jd,double xyz[3], void*);
-void get_dione_parent_coordsv(double jd,double xyz[3], void*);
-void get_rhea_parent_coordsv(double jd,double xyz[3], void*);
-void get_titan_parent_coordsv(double jd,double xyz[3], void*);
-void get_hyperion_parent_coordsv(double jd,double xyz[3], void*);
-void get_iapetus_parent_coordsv(double jd,double xyz[3], void*);
-
-void get_miranda_parent_coordsv(double jd,double xyz[3], void*);
-void get_ariel_parent_coordsv(double jd,double xyz[3], void*);
-void get_umbriel_parent_coordsv(double jd,double xyz[3], void*);
-void get_titania_parent_coordsv(double jd,double xyz[3], void*);
-void get_oberon_parent_coordsv(double jd,double xyz[3], void*);
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif /* _STELLPLANET_H_ */
 
=== modified file 'src/core/planetsephems/vsop87.h'
--- src/core/planetsephems/vsop87.h	2015-07-20 15:56:19 +0000
+++ src/core/planetsephems/vsop87.h	2016-01-16 17:00:50 +0000
@@ -51,15 +51,6 @@
 extern "C" {
 #endif
 
-#define VSOP87_MERCURY  0
-#define VSOP87_VENUS    1
-#define VSOP87_EMB      2
-#define VSOP87_MARS     3
-#define VSOP87_JUPITER  4
-#define VSOP87_SATURN   5
-#define VSOP87_URANUS   6
-#define VSOP87_NEPTUNE  7
-
 void GetVsop87Coor(double jd,int body,double *xyz);
   /* Return the rectangular coordinates of the given planet
      and the given julian date jd expressed in dynamical time (TAI+32.184s).
 
=== modified file 'src/gui/ConfigurationDialog.cpp'
--- src/gui/ConfigurationDialog.cpp	2015-11-29 14:05:01 +0000
+++ src/gui/ConfigurationDialog.cpp	2016-01-16 17:00:50 +0000
@@ -59,6 +59,7 @@
 #include "SkyGui.hpp"
 #include "StelJsonParser.hpp"
 #include "StelTranslator.hpp"
+#include "EphemWrapper.hpp"
 
 #include <QSettings>
 #include <QDebug>
@@ -72,15 +73,17 @@
 	: StelDialog(parent)
 	, nextStarCatalogToDownloadIndex(0)
 	, starCatalogsCount(0)
-	, starCatalogDownloadReply(NULL)
+	, downloadReply(NULL)
 	, currentDownloadFile(NULL)
 	, progressBar(NULL)
 	, gui(agui)
+	, hasDownloadedStarCatalog(false)
+	, isDownloadingStarCatalog(false)
+	, isDownloadingEphemData(false)
+	, customDeltaTEquationDialog(NULL)
 {
 	ui = new Ui_configurationDialogForm;
-	customDeltaTEquationDialog = NULL;
-	hasDownloadedStarCatalog = false;
-	isDownloadingStarCatalog = false;
+
 	savedProjectionType = StelApp::getInstance().getCore()->getCurrentProjectionType();
 	// Get info about operating system
 	QString platform = StelUtils::getOperatingSystemInfo();
@@ -170,11 +173,18 @@
 	connect(ui->getStarsButton, SIGNAL(clicked()), this, SLOT(downloadStars()));
 	connect(ui->downloadCancelButton, SIGNAL(clicked()), this, SLOT(cancelDownload()));
 	connect(ui->downloadRetryButton, SIGNAL(clicked()), this, SLOT(downloadStars()));
-	resetStarCatalogControls();
+	
 	ui->nutationCheckBox->setChecked(core->getUseNutation());
 	connect(ui->nutationCheckBox, SIGNAL(toggled(bool)), core, SLOT(setUseNutation(bool)));
 	ui->topocentricCheckBox->setChecked(core->getUseTopocentricCoordinates());
 	connect(ui->topocentricCheckBox, SIGNAL(toggled(bool)), core, SLOT(setUseTopocentricCoordinates(bool)));
+
+	connect(ui->de430checkBox, SIGNAL(clicked()), this, SLOT(de430ButtonClicked()));
+	connect(ui->de431checkBox, SIGNAL(clicked()), this, SLOT(de431ButtonClicked()));
+	
+	resetStarCatalogControls();
+	resetEphemControls();
+
 #ifdef Q_OS_WIN
 	//Kinetic scrolling for tablet pc and pc
 	QList<QWidget *> addscroll;
@@ -1077,27 +1087,27 @@
 void ConfigurationDialog::cancelDownload(void)
 {
 	Q_ASSERT(currentDownloadFile);
-	Q_ASSERT(starCatalogDownloadReply);
+	Q_ASSERT(downloadReply);
 	qWarning() << "Aborting download";
-	starCatalogDownloadReply->abort();
+	downloadReply->abort();
 }
 
 void ConfigurationDialog::newStarCatalogData()
 {
 	Q_ASSERT(currentDownloadFile);
-	Q_ASSERT(starCatalogDownloadReply);
+	Q_ASSERT(downloadReply);
 	Q_ASSERT(progressBar);
 
-	int size = starCatalogDownloadReply->bytesAvailable();
+	int size = downloadReply->bytesAvailable();
 	progressBar->setValue((float)progressBar->getValue()+(float)size/1024);
-	currentDownloadFile->write(starCatalogDownloadReply->read(size));
+	currentDownloadFile->write(downloadReply->read(size));
 }
 
 void ConfigurationDialog::downloadStars()
 {
 	Q_ASSERT(!nextStarCatalogToDownload.isEmpty());
 	Q_ASSERT(!isDownloadingStarCatalog);
-	Q_ASSERT(starCatalogDownloadReply==NULL);
+	Q_ASSERT(downloadReply==NULL);
 	Q_ASSERT(currentDownloadFile==NULL);
 	Q_ASSERT(progressBar==NULL);
 
@@ -1112,7 +1122,7 @@
 		ui->downloadRetryButton->setVisible(true);
 		return;
 	}
-
+	isDownloading = true;
 	isDownloadingStarCatalog = true;
 	updateStarCatalogControlsText();
 	ui->downloadCancelButton->setVisible(true);
@@ -1124,10 +1134,10 @@
 	req.setAttribute(QNetworkRequest::CacheSaveControlAttribute, false);
 	req.setAttribute(QNetworkRequest::RedirectionTargetAttribute, false);
 	req.setRawHeader("User-Agent", userAgent.toLatin1());
-	starCatalogDownloadReply = StelApp::getInstance().getNetworkAccessManager()->get(req);
-	starCatalogDownloadReply->setReadBufferSize(1024*1024*2);	
-	connect(starCatalogDownloadReply, SIGNAL(finished()), this, SLOT(downloadFinished()));
-	connect(starCatalogDownloadReply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(downloadError(QNetworkReply::NetworkError)));
+	downloadReply = StelApp::getInstance().getNetworkAccessManager()->get(req);
+	downloadReply->setReadBufferSize(1024*1024*2);	
+	connect(downloadReply, SIGNAL(finished()), this, SLOT(starsDownloadFinished()));
+	connect(downloadReply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(downloadError(QNetworkReply::NetworkError)));
 
 	progressBar = StelApp::getInstance().addProgressBar();
 	progressBar->setValue(0);
@@ -1137,30 +1147,97 @@
 	qDebug() << "Downloading file" << nextStarCatalogToDownload.value("url").toString();
 }
 
+void ConfigurationDialog::de430ButtonClicked()
+{
+	QSettings* conf = StelApp::getInstance().getSettings();
+	Q_ASSERT(conf);
+
+	StelApp::getInstance().getCore()->setDe430Active(!StelApp::getInstance().getCore()->de430IsActive());
+	conf->setValue("astro/flag_use_de430", StelApp::getInstance().getCore()->de430IsActive());
+
+	resetEphemControls(); //refresh labels
+}
+
+void ConfigurationDialog::de431ButtonClicked()
+{
+	QSettings* conf = StelApp::getInstance().getSettings();
+	Q_ASSERT(conf);
+
+	StelApp::getInstance().getCore()->setDe431Active(!StelApp::getInstance().getCore()->de431IsActive());
+	conf->setValue("astro/flag_use_de431", StelApp::getInstance().getCore()->de431IsActive());
+
+	resetEphemControls(); //refresh labels
+}
+
+void ConfigurationDialog::resetEphemControls()
+{
+	ui->de430checkBox->setEnabled(StelApp::getInstance().getCore()->de430IsAvailable());
+	ui->de431checkBox->setEnabled(StelApp::getInstance().getCore()->de431IsAvailable());
+	ui->de430checkBox->setChecked(StelApp::getInstance().getCore()->de430IsActive());
+	ui->de431checkBox->setChecked(StelApp::getInstance().getCore()->de431IsActive());
+
+	if(StelApp::getInstance().getCore()->de430IsActive())
+		ui->de430label->setText(q_("1550...2650"));
+	else
+	{
+		if (StelApp::getInstance().getCore()->de430IsAvailable())
+			ui->de430label->setText(q_("Available"));
+		else
+			ui->de430label->setText(q_("Not Available"));
+	}
+	if(StelApp::getInstance().getCore()->de431IsActive())
+		ui->de431label->setText(q_("-13.000...17.000"));
+	else
+	{
+		if (StelApp::getInstance().getCore()->de431IsAvailable())
+			ui->de431label->setText(q_("Available"));
+		else
+			ui->de431label->setText(q_("Not Available"));
+	}
+}
+
+void ConfigurationDialog::downloadEphemData()
+{
+	// TODO in connection with the download manager!
+	resetEphemControls();
+}
+
 void ConfigurationDialog::downloadError(QNetworkReply::NetworkError)
 {
 	Q_ASSERT(currentDownloadFile);
-	Q_ASSERT(starCatalogDownloadReply);
-
-	isDownloadingStarCatalog = false;
-	qWarning() << "Error downloading file" << starCatalogDownloadReply->url() << ": " << starCatalogDownloadReply->errorString();
-	ui->downloadLabel->setText(q_("Error downloading %1:\n%2").arg(nextStarCatalogToDownload.value("id").toString()).arg(starCatalogDownloadReply->errorString()));
+	Q_ASSERT(downloadReply);
+
+	isDownloading = false;
+    if(isDownloadingStarCatalog)
+    {
+    	isDownloadingStarCatalog = false;
+    	ui->getStarsButton->setVisible(false);
+		ui->getStarsButton->setEnabled(true);
+    }
+
+	qWarning() << "Error downloading file" << downloadReply->url() << ": " << downloadReply->errorString();
+	ui->downloadLabel->setText(q_("Error downloading %1:\n%2").arg(nextStarCatalogToDownload.value("id").toString()).arg(downloadReply->errorString()));
 	ui->downloadCancelButton->setVisible(false);
 	ui->downloadRetryButton->setVisible(true);
-	ui->getStarsButton->setVisible(false);
-	ui->getStarsButton->setEnabled(true);
-}
-
-void ConfigurationDialog::downloadFinished()
+	
+}
+
+void ConfigurationDialog::ephemDataDownloadFinished()
+{
+	// TODO in connection with the download manager!
+
+}
+
+void ConfigurationDialog::starsDownloadFinished()
 {
 	Q_ASSERT(currentDownloadFile);
-	Q_ASSERT(starCatalogDownloadReply);
+	Q_ASSERT(downloadReply);
 	Q_ASSERT(progressBar);
 
-	if (starCatalogDownloadReply->error()!=QNetworkReply::NoError)
+	if (downloadReply->error()!=QNetworkReply::NoError)
 	{
-		starCatalogDownloadReply->deleteLater();
-		starCatalogDownloadReply = NULL;
+		downloadReply->deleteLater();
+		downloadReply = NULL;
 		currentDownloadFile->close();
 		currentDownloadFile->deleteLater();
 		currentDownloadFile = NULL;
@@ -1169,31 +1246,34 @@
 		return;
 	}
 
-	const QVariant& redirect = starCatalogDownloadReply->attribute(QNetworkRequest::RedirectionTargetAttribute);
+	Q_ASSERT(downloadReply->bytesAvailable()==0);
+
+	const QVariant& redirect = downloadReply->attribute(QNetworkRequest::RedirectionTargetAttribute);
 	if (!redirect.isNull())
 	{
 		// We got a redirection, we need to follow
-		starCatalogDownloadReply->deleteLater();
+		downloadReply->deleteLater();
 		QNetworkRequest req(redirect.toUrl());
 		req.setAttribute(QNetworkRequest::CacheSaveControlAttribute, false);
 		req.setAttribute(QNetworkRequest::RedirectionTargetAttribute, false);
 		req.setRawHeader("User-Agent", userAgent.toLatin1());
-		starCatalogDownloadReply = StelApp::getInstance().getNetworkAccessManager()->get(req);
-		starCatalogDownloadReply->setReadBufferSize(1024*1024*2);
-		connect(starCatalogDownloadReply, SIGNAL(readyRead()), this, SLOT(newStarCatalogData()));
-		connect(starCatalogDownloadReply, SIGNAL(finished()), this, SLOT(downloadFinished()));
-		connect(starCatalogDownloadReply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(downloadError(QNetworkReply::NetworkError)));
+		downloadReply = StelApp::getInstance().getNetworkAccessManager()->get(req);
+		downloadReply->setReadBufferSize(1024*1024*2);
+		connect(downloadReply, SIGNAL(readyRead()), this, SLOT(newStarCatalogData()));
+		connect(downloadReply, SIGNAL(finished()), this, SLOT(starsDownloadFinished()));
+		connect(downloadReply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(downloadError(QNetworkReply::NetworkError)));
 		return;
 	}
 
-	Q_ASSERT(starCatalogDownloadReply->bytesAvailable()==0);
+	Q_ASSERT(downloadReply->bytesAvailable()==0);
 
 	isDownloadingStarCatalog = false;
+	isDownloading = false;
 	currentDownloadFile->close();
 	currentDownloadFile->deleteLater();
 	currentDownloadFile = NULL;
-	starCatalogDownloadReply->deleteLater();
-	starCatalogDownloadReply = NULL;
+	downloadReply->deleteLater();
+	downloadReply = NULL;
 	StelApp::getInstance().removeProgressBar(progressBar);
 	progressBar=NULL;
 
 
=== modified file 'src/gui/ConfigurationDialog.hpp'
--- src/gui/ConfigurationDialog.hpp	2015-08-19 11:23:26 +0000
+++ src/gui/ConfigurationDialog.hpp	2016-01-16 17:00:50 +0000
@@ -60,20 +60,26 @@
 	//! Re-translate the contents of the "Star calalogs" box.
 	//! Update the strings according to the state.
 	void updateStarCatalogControlsText();
-	//! True if a star catalog download is in progress.
-	bool isDownloadingStarCatalog;
 	//! Value set by resetStarCatalogControls().
 	int nextStarCatalogToDownloadIndex;
 	//! Value set by resetStarCatalogControls().
 	int starCatalogsCount;
 	//! True when at least one star catalog has been downloaded successfully this session
 	bool hasDownloadedStarCatalog;
-	QNetworkReply* starCatalogDownloadReply;
+	QNetworkReply* downloadReply;
 	QFile* currentDownloadFile;
 	class StelProgressController* progressBar;
 
 	QString userAgent;
 
+	//! True if a star catalog download is in progress.
+	bool isDownloadingStarCatalog;
+	//! True if a ephemData download is in progress.
+	bool isDownloadingEphemData;
+	//! True if any download is in progress
+	bool isDownloading;
+
+
 private slots:
 	void setNoSelectedInfo();
 	void setAllSelectedInfo();
@@ -100,7 +106,9 @@
 	void newStarCatalogData();
 	void downloadStars();
 	void cancelDownload();
-	void downloadFinished();
+	void starsDownloadFinished();
+	void ephemDataDownloadFinished();
+	void resetEphemControls();
 	void downloadError(QNetworkReply::NetworkError);
 
 	//! Update the labels displaying the current default state
@@ -148,6 +156,12 @@
 	#endif
 	void setFixedDateTimeToCurrent();
 
+	//! downloads DE430/DE431 ephemData from SourceForge
+	void downloadEphemData();
+
+	void de430ButtonClicked();
+	void de431ButtonClicked();
+
 private:
 	StelGui* gui;
 
 
=== modified file 'src/gui/configurationDialog.ui'
--- src/gui/configurationDialog.ui	2015-11-08 09:52:30 +0000
+++ src/gui/configurationDialog.ui	2016-01-16 17:00:50 +0000
@@ -6,7 +6,7 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>497</width>
+    <width>509</width>
     <height>538</height>
    </rect>
   </property>
@@ -168,7 +168,7 @@
            <number>0</number>
           </property>
           <item>
-           <widget class="QGroupBox" name="groupBox_2">
+           <widget class="QGroupBox" name="groupBox_LanguageSettings">
             <property name="title">
              <string>Language settings</string>
             </property>
@@ -269,6 +269,75 @@
            </widget>
           </item>
           <item>
+           <widget class="QGroupBox" name="groupBox_EphemerisSettings">
+            <property name="title">
+             <string>Ephemeris settings</string>
+            </property>
+            <layout class="QGridLayout" name="gridLayout_ephemeris">
+             <property name="leftMargin">
+              <number>0</number>
+             </property>
+             <property name="topMargin">
+              <number>0</number>
+             </property>
+             <property name="rightMargin">
+              <number>0</number>
+             </property>
+             <property name="bottomMargin">
+              <number>0</number>
+             </property>
+             <item row="0" column="0">
+              <layout class="QGridLayout" name="EphemerisGridLayout">
+               <item row="1" column="1">
+                <widget class="QLabel" name="de431label">
+                 <property name="text">
+                  <string>Not installed</string>
+                 </property>
+                </widget>
+               </item>
+               <item row="0" column="1">
+                <widget class="QLabel" name="de430label">
+                 <property name="text">
+                  <string>Not installed</string>
+                 </property>
+                </widget>
+               </item>
+               <item row="1" column="0">
+                <widget class="QCheckBox" name="de431checkBox">
+                 <property name="toolTip">
+                  <string>DE431 provides position data for years -13000...+17000. For special applications only.</string>
+                 </property>
+                 <property name="text">
+                  <string>Use DE431 (long-time data)</string>
+                 </property>
+                </widget>
+               </item>
+               <item row="0" column="0">
+                <widget class="QCheckBox" name="de430checkBox">
+                 <property name="toolTip">
+                  <string>DE430 provides highest accuracy, only for years 1550...2650.</string>
+                 </property>
+                 <property name="text">
+                  <string>Use DE430 (high accuracy)</string>
+                 </property>
+                </widget>
+               </item>
+               <item row="2" column="0" colspan="2">
+                <widget class="QLabel" name="label_VSOP87used">
+                 <property name="toolTip">
+                  <string>Using VSOP87 is recommended for years -4000...+8000 only, but delivers useful positions outside this range.</string>
+                 </property>
+                 <property name="text">
+                  <string>VSOP87/ELP2000-82B is used when these are not installed or not activated.</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </item>
+            </layout>
+           </widget>
+          </item>
+          <item>
            <widget class="QGroupBox" name="groupBox_6">
             <property name="title">
              <string>Default options</string>
@@ -1143,16 +1212,6 @@
                </property>
               </widget>
              </item>
-             <item row="7" column="0" colspan="2">
-              <widget class="QCheckBox" name="autoZoomResetsDirectionCheckbox">
-               <property name="toolTip">
-                <string>When enabled, the &quot;auto zoom out&quot; key will also set the initial viewing direction</string>
-               </property>
-               <property name="text">
-                <string>Auto zoom out returns to initial direction of view</string>
-               </property>
-              </widget>
-             </item>
              <item row="3" column="1">
               <widget class="QCheckBox" name="decimalDegreeCheckBox">
                <property name="toolTip">
@@ -1193,6 +1252,16 @@
                </property>
               </widget>
              </item>
+             <item row="6" column="0" colspan="2">
+              <widget class="QCheckBox" name="autoZoomResetsDirectionCheckbox">
+               <property name="toolTip">
+                <string>When enabled, the &quot;auto zoom out&quot; key will also set the initial viewing direction</string>
+               </property>
+               <property name="text">
+                <string>Auto zoom out returns to initial direction of view</string>
+               </property>
+              </widget>
+             </item>
             </layout>
            </widget>
           </item>