Merge lp:~stellarium/stellarium/fix-DeltaT into lp:stellarium

[gzotti]

See branch description, also on tests. The branch untangles applications of DeltaT, it should be clear now what flavour of JD to use in which situation.

I have placed comments in many places which have changed. These will go away during merge when no longer needed. There are very few cases in the "object plugins" (Supernovae, pulsars, ...) where it is not clear to me which kind of JD (JD or JDE) was in the original catalog for discovery date. Most likely these cases are JDE (as was also in use via the previous getJDay() call).

[Alexander Wolf (alexwolf)]

I think it ready to merge

review: Approve

[lp:~stellarium/stellarium/fix-DeltaT]

7755. By gzotti on 2015-08-03

most explanatory pre-review comments removed before merge. A few have to stay in, explain open questions for plugin authors!

=== modified file 'plugins/AngleMeasure/src/AngleMeasure.hpp'
--- plugins/AngleMeasure/src/AngleMeasure.hpp	2015-05-31 09:35:00 +0000
+++ plugins/AngleMeasure/src/AngleMeasure.hpp	2015-08-03 13:17:13 +0000
@@ -34,8 +34,10 @@
 /*! @defgroup angleMeasure Angle Measure plug-in
 @{
 The Angle Measure plugin is a small tool which is used to measure
-the angular distance between two points on the sky. *goes misty eyed*
-I recall measuring the size of the Cassini Division when I was a student.
+the angular distance between two points on the sky.
+
+*goes misty eyed* I recall measuring the size of the Cassini Division
+when I was a student.
 It was not the high academic glamor one might expect... It was cloudy...
 It was rainy... The observatory lab had some old scopes set up at one end,
 pointing at a photograph of Saturn at the other end of the lab. We measured.
@@ -64,7 +66,7 @@
 //! Main class of the Angle Measure plug-in.
 //! @author Matthew Gates
 //! @author Alexander Wolf
-//! @anchor Georg Zotti
+//! @author Georg Zotti
 class AngleMeasure : public StelModule
 {
 	Q_OBJECT

=== modified file 'plugins/ArchaeoLines/src/ArchaeoLines.cpp'
--- plugins/ArchaeoLines/src/ArchaeoLines.cpp	2015-05-16 10:23:09 +0000
+++ plugins/ArchaeoLines/src/ArchaeoLines.cpp	2015-08-03 13:17:13 +0000
@@ -79,7 +79,7 @@
 	, flagShowCurrentSun(false)
 	, flagShowCurrentMoon(false)
 	, enumShowCurrentPlanet(ArchaeoLine::CurrentPlanetNone)
-	, lastJD(0.0)
+	, lastJDE(0.0)
 	, toolbarButton(NULL)
 {
 	setObjectName("ArchaeoLines");
@@ -212,6 +212,9 @@
 
 void ArchaeoLines::update(double deltaTime)
 {
+	if (core->getCurrentPlanet()->getEnglishName()!="Earth")
+		return;
+
 	static SolarSystem *ssystem=GETSTELMODULE(SolarSystem);
 	static const double lunarI=5.145396; // inclination of lunar orbit
 	// compute min and max distance values for horizontal parallax.
@@ -244,16 +247,16 @@
 		currentPlanetLine->setDeclination(dec_equ * 180.0/M_PI);
 	}
 
-	double newJD=core->getJDay();
-	if (fabs(newJD-lastJD) > 10.0) // enough to compute this every 10 days?
+	double newJDE=core->getJDE();
+	if (fabs(newJDE-lastJDE) > 10.0) // enough to compute this every 10 days?
 	{
-		eps= ssystem->getEarth()->getRotObliquity(core->getJDay()) *180.0/M_PI;
+		eps= ssystem->getEarth()->getRotObliquity(newJDE) *180.0/M_PI;
 		static const double invSqrt2=1.0/std::sqrt(2.0);
 		northernSolsticeLine->setDeclination( eps);
 		southernSolsticeLine->setDeclination(-eps);
 		northernCrossquarterLine->setDeclination( eps*invSqrt2);
 		southernCrossquarterLine->setDeclination(-eps*invSqrt2);
-		lastJD=newJD;
+		lastJDE=newJDE;
 	}
 	StelLocation loc=core->getCurrentLocation();
 
@@ -347,6 +350,9 @@
 //! Draw any parts on the screen which are for our module
 void ArchaeoLines::draw(StelCore* core)
 {
+	if (core->getCurrentPlanet()->getEnglishName()!="Earth")
+		return;
+
 	equinoxLine->draw(core, lineFader.getInterstate());
 	northernSolsticeLine->draw(core, lineFader.getInterstate());
 	southernSolsticeLine->draw(core, lineFader.getInterstate());

=== modified file 'plugins/ArchaeoLines/src/ArchaeoLines.hpp'
--- plugins/ArchaeoLines/src/ArchaeoLines.hpp	2015-05-30 19:56:47 +0000
+++ plugins/ArchaeoLines/src/ArchaeoLines.hpp	2015-08-03 13:17:13 +0000
@@ -272,7 +272,7 @@
 	bool flagShowCurrentSun;
 	bool flagShowCurrentMoon;
 	ArchaeoLine::Line enumShowCurrentPlanet;
-	double lastJD; // cache last-time-computed to 1/month or so?
+	double lastJDE; // cache last-time-computed to every 10 days or so?
 
 	ArchaeoLine * equinoxLine;
 	ArchaeoLine * northernSolsticeLine;

=== modified file 'plugins/EquationOfTime/src/EquationOfTime.cpp'
--- plugins/EquationOfTime/src/EquationOfTime.cpp	2015-03-22 09:33:56 +0000
+++ plugins/EquationOfTime/src/EquationOfTime.cpp	2015-08-03 13:17:13 +0000
@@ -113,6 +113,8 @@
 {
 	if (!isEnabled())
 		return;
+	if (core->getCurrentPlanet()->getEnglishName()!="Earth")
+		return;
 
 	StelPainter sPainter(core->getProjection2d());
 	sPainter.setColor(textColor[0], textColor[1], textColor[2], 1.f);
@@ -120,26 +122,26 @@
 	sPainter.setFont(font);
 
 	QString timeText;
-	double time = getSolutionEquationOfTime(core->getJDay());
+	double eqTime = getSolutionEquationOfTime(core->getJDE());
 
 	if (getFlagInvertedValue())
-		time *= -1;
+		eqTime *= -1;
 
 	if (getFlagMsFormat())
 	{
-		int seconds = qRound((time - (int)time)*60);
+		int seconds = qRound((eqTime - (int)eqTime)*60);
 		QString messageSecondsValue = QString("%1").arg(qAbs(seconds), 2, 10, QLatin1Char('0'));
 
-		timeText = QString("%1: %2%3%4%5%6").arg(messageEquation, (time<0? QString(QLatin1Char('-')):QString()), QString::number((int)qAbs(time)), messageEquationMinutes, messageSecondsValue, messageEquationSeconds);
+		timeText = QString("%1: %2%3%4%5%6").arg(messageEquation, (eqTime<0? QString(QLatin1Char('-')):QString()), QString::number((int)qAbs(eqTime)), messageEquationMinutes, messageSecondsValue, messageEquationSeconds);
 	}
 	else
-		timeText = QString("%1: %2%3").arg(messageEquation, QString::number(time, 'f', 2), messageEquationMinutes);
+		timeText = QString("%1: %2%3").arg(messageEquation, QString::number(eqTime, 'f', 2), messageEquationMinutes);
 
 
 	QFontMetrics fm(font);
 	QSize fs = fm.size(Qt::TextSingleLine, timeText);	
-	if (core->getCurrentPlanet().data()->getEnglishName()=="Earth")
-		sPainter.drawText(gui->getSkyGui()->getSkyGuiWidth()/2 - fs.width()/2, gui->getSkyGui()->getSkyGuiHeight() - fs.height()*1.5, timeText);
+
+	sPainter.drawText(gui->getSkyGui()->getSkyGuiWidth()/2 - fs.width()/2, gui->getSkyGui()->getSkyGuiHeight() - fs.height()*1.5, timeText);
 
 	//qDebug() << timeText;
 }
@@ -212,11 +214,11 @@
 	conf->endGroup();
 }
 
-double EquationOfTime::getSolutionEquationOfTime(const double JDay) const
+double EquationOfTime::getSolutionEquationOfTime(const double JDE) const
 {
 	StelCore* core = StelApp::getInstance().getCore();
 
-	double tau = (JDay - 2451545.0)/365250.0;
+	double tau = (JDE - 2451545.0)/365250.0;
 	double sunMeanLongitude = 280.4664567 + tau*(360007.6892779 + tau*(0.03032028 + tau*(1./49931. - tau*(1./15300. - tau/2000000.))));
 
 	// reduce the angle
@@ -233,7 +235,7 @@
 	// force it to be the positive remainder, so that 0 <= angle < 360
 	alpha = std::fmod(alpha + 360., 360.);
 
-	double equation = 4*(sunMeanLongitude - 0.0057183 - alpha + get_nutation_longitude(JDay)*cos(get_mean_ecliptical_obliquity(JDay)));
+	double equation = 4*(sunMeanLongitude - 0.0057183 - alpha + get_nutation_longitude(JDE)*cos(get_mean_ecliptical_obliquity(JDE)));
 	// The equation of time is always smaller 20 minutes in absolute value
 	if (qAbs(equation)>20)
 	{

=== modified file 'plugins/EquationOfTime/src/EquationOfTime.hpp'
--- plugins/EquationOfTime/src/EquationOfTime.hpp	2015-05-31 09:35:00 +0000
+++ plugins/EquationOfTime/src/EquationOfTime.hpp	2015-08-03 13:17:13 +0000
@@ -87,9 +87,9 @@
 
 	//! Get solution of equation of time
 	//! Source: J. Meeus "Astronomical Algorithms" (2nd ed., with corrections as of August 10, 2009) p.183-187.
-	//! @param JDay JD
+	//! @param JDE JD in Dynamical Time (previously called Ephemeris Time)
 	//! @return time in minutes
-	double getSolutionEquationOfTime(const double JDay) const;
+	double getSolutionEquationOfTime(const double JDE) const;
 
 	//! Is plugin enabled?
 	bool isEnabled() const

=== modified file 'plugins/Exoplanets/src/Exoplanet.cpp'
--- plugins/Exoplanets/src/Exoplanet.cpp	2015-01-16 19:33:33 +0000
+++ plugins/Exoplanets/src/Exoplanet.cpp	2015-08-03 13:17:13 +0000
@@ -417,7 +417,7 @@
 	QList<int> discovery;
 	// For getting value of new year from midnight at 1 Jan we need increase a value of JD on 0.5.
 	// This hack need for correct display of discovery mode of exoplanets.
-	StelUtils::getDateFromJulianDay(core->getJDay()+0.5, &year, &month, &day);
+	StelUtils::getDateFromJulianDay(core->getJD()+0.5, &year, &month, &day);
 	discovery.clear();
 	foreach(const exoplanetData &p, exoplanets)
 	{

=== modified file 'plugins/MeteorShowers/src/MeteorShower.cpp'
--- plugins/MeteorShowers/src/MeteorShower.cpp	2015-04-22 01:04:29 +0000
+++ plugins/MeteorShowers/src/MeteorShower.cpp	2015-08-03 13:17:13 +0000
@@ -206,9 +206,9 @@
 QDateTime MeteorShower::getSkyQDateTime() const
 {
 	StelCore* core = StelApp::getInstance().getCore();
-	//get the current sky date
-	double JD = core->getJDay();
-	return StelUtils::jdToQDateTime(JD+StelUtils::getGMTShiftFromQT(JD)/24-core->getDeltaT(JD)/86400);
+	//get the current sky date (zone time)
+	double JD = core->getJD();
+	return StelUtils::jdToQDateTime(JD+ StelUtils::getGMTShiftFromQT(JD)/24);
 }
 
 void MeteorShower::updateCurrentData(QDateTime skyDate)

=== modified file 'plugins/MeteorShowers/src/MeteorShowers.cpp'
--- plugins/MeteorShowers/src/MeteorShowers.cpp	2015-04-11 13:25:02 +0000
+++ plugins/MeteorShowers/src/MeteorShowers.cpp	2015-08-03 13:17:13 +0000
@@ -215,7 +215,8 @@
 	updateTimer->start();
 
 	// skyDate startup
-	skyDate = StelUtils::jdToQDateTime(StelApp::getInstance().getCore()->getJDay());
+	// GZ JDfix for 0.14 I am not sure how skyDate is used. It used to be set to JDE, so again:
+	skyDate = StelUtils::jdToQDateTime(StelApp::getInstance().getCore()->getJDE());
 
 	GETSTELMODULE(StelObjectMgr)->registerStelObjectMgr(this);
 }
@@ -273,8 +274,8 @@
 
 bool MeteorShowers::changedSkyDate(StelCore* core)
 {
-	double JD = core->getJDay();
-	skyDate = StelUtils::jdToQDateTime(JD+StelUtils::getGMTShiftFromQT(JD)/24-core->getDeltaT(JD)/86400);
+	double JD = core->getJD();
+	skyDate = StelUtils::jdToQDateTime(JD+StelUtils::getGMTShiftFromQT(JD)/24);
 	if (skyDate.toString("MM.dd.yyyy") != lastSkyDate.toString("MM.dd.yyyy"))  //if the sky date changed
 	{
 		return true;

=== modified file 'plugins/MeteorShowers/src/gui/MeteorShowerDialog.cpp'
--- plugins/MeteorShowers/src/gui/MeteorShowerDialog.cpp	2015-07-29 18:56:52 +0000
+++ plugins/MeteorShowers/src/gui/MeteorShowerDialog.cpp	2015-08-03 13:17:13 +0000
@@ -237,7 +237,8 @@
 	//Change date
 	QString dateString = treeWidget->currentItem()->text(ColumnPeak);
 	QDateTime qDateTime = QDateTime::fromString(dateString, "dd/MMM/yyyy");
-	core->setJDay(StelUtils::qDateTimeToJd(qDateTime));
+	// GZ JDfix for V0.14 this used to set JDE, so again. If IMO ephemerides are JD(UT), please change.
+	core->setJDE(StelUtils::qDateTimeToJd(qDateTime));
 
 	//Select object
 	QString namel18n = treeWidget->currentItem()->text(ColumnName);

=== modified file 'plugins/Novae/src/Nova.cpp'
--- plugins/Novae/src/Nova.cpp	2015-02-08 15:35:27 +0000
+++ plugins/Novae/src/Nova.cpp	2015-08-03 13:17:13 +0000
@@ -167,7 +167,7 @@
 {
 	// OK, start from minimal brightness
 	double vmag = minMagnitude;
-	double currentJD = core->getJDay();
+	double currentJD = core->getJDE();
 	double deltaJD = qAbs(peakJD-currentJD);
     
 	// Fill "default" values for mX

=== modified file 'plugins/Novae/src/Nova.hpp'
--- plugins/Novae/src/Nova.hpp	2015-05-30 19:56:47 +0000
+++ plugins/Novae/src/Nova.hpp	2015-08-03 13:17:13 +0000
@@ -37,6 +37,11 @@
 //! Details about the novae are passed using a QVariant which contains
 //! a map of data from the json file.
 //! @ingroup brightNovae
+//
+// GZ NOTE from JDfix for V0.14:
+// TODO: I don't know whether the peak times given are UT or DT times.
+// If DT, please change relevant calls from core->getJD() to getJDE() etc
+// and rename variables to include JDE for clarity.
 
 class Nova : public StelObject
 {

=== modified file 'plugins/Observability/src/Observability.cpp'
--- plugins/Observability/src/Observability.cpp	2014-11-26 18:14:09 +0000
+++ plugins/Observability/src/Observability.cpp	2015-08-03 13:17:13 +0000
@@ -72,6 +72,17 @@
 	return info;
 }
 
+// TODO: Migrate to static const? --BM ==> GZ during JDfix for 0.14: SURE!
+// Some useful constants:
+const double Observability::Rad2Deg = 180./M_PI;         // Convert degrees into radians
+const double Observability::Rad2Hr = 12./M_PI;           // Convert hours into radians
+const double Observability::UA =  AU;                    // 1.4958e+8;         // Astronomical Unit in Km. ==> HAS BEEN DEFINED IN StelUtils.hpp!
+const double Observability::TFrac = 0.9972677595628414;  // Convert sidereal time into Solar time
+const double Observability::JDsec = 1./86400.;           // A second in days. ==> TODO USE StelCore::JD_SECOND instead
+const double Observability::halfpi = M_PI * 0.5;         //  1.57079632675; // pi/2
+const double Observability::MoonT = 29.530588;           // Moon synodic period (used as first estimate of Full Moon). ==> FIND MORE DEC. PLACES!
+const double Observability::RefFullMoon = 2451564.696; // Reference Julian date of a Full Moon.
+const double Observability::MoonPerilune = 0.0024236308; // Smallest Earth-Moon distance (in AU).
 
 
 Observability::Observability()
@@ -110,17 +121,6 @@
 	setObjectName("Observability");
 	configDialog = new ObservabilityDialog();
 
-	// TODO: Migrate to static const? --BM
-	// Some useful constants:
-	Rad2Deg = 180./3.1415927; // Convert degrees into radians
-	Rad2Hr = 12./3.1415927;  // Convert hours into radians
-	UA = 1.4958e+8;         // Astronomical Unit in Km.
-	TFrac = 0.9972677595628414;  // Convert sidereal time into Solar time
-	JDsec = 1./86400.;      // A second in days.
-	halfpi = 1.57079632675; // pi/2
-	MoonT = 29.530588; // Moon synodic period (used as first estimate of Full Moon).
-	RefFullMoon = 2451564.696; // Reference Julian date of a Full Moon.
-	MoonPerilune = 0.0024236308; // Smallest Earth-Moon distance (in AU).
 	
 	nextFullMoon = 0.0;
 	prevFullMoon = 0.0;
@@ -129,7 +129,8 @@
 
 	// Dummy initial values for parameters and data vectors:
 	mylat = 1000.; mylon = 1000.;
-	myJD = 0.0;
+	myJD.first = 0.0;
+	myJD.second = 0.0;
 	curYear = 0;
 	isStar = true;
 	isMoon = false;
@@ -146,13 +147,21 @@
 
 	// I think this can be done in a more simple way...--BM
 	for (int i=0;i<366;i++) {
-		sunRA[i] = 0.0; sunDec[i] = 0.0;
-		objectRA[i] = 0.0; objectDec[i]=0.0;
-		sunSidT[0][i]=0.0; sunSidT[1][i]=0.0;
-		objectSidT[0][i]=0.0; objectSidT[1][i]=0.0;
-		objectH0[i] = 0.0;
-		yearJD[i] = 0.0;
+//		sunRA[i] = 0.0; sunDec[i] = 0.0;
+//		objectRA[i] = 0.0; objectDec[i]=0.0;
+//		sunSidT[0][i]=0.0; sunSidT[1][i]=0.0;
+//		objectSidT[0][i]=0.0; objectSidT[1][i]=0.0;
+//		objectH0[i] = 0.0;
+		yearJD[i]=QPair<double, double>(0.0, 0.0);
 	};
+	// GZ Sure:
+	memset(sunRA,      0,   366*sizeof(double));
+	memset(sunDec,     0,   366*sizeof(double));
+	memset(objectRA,   0,   366*sizeof(double));
+	memset(objectDec,  0,   366*sizeof(double));
+	memset(sunSidT,    0, 2*366*sizeof(double));
+	memset(objectSidT, 0, 2*366*sizeof(double));
+	memset(objectH0,   0,   366*sizeof(double));
 
 }
 
@@ -281,7 +290,7 @@
 	double currlat = (core->getCurrentLocation().latitude)/Rad2Deg;
 	double currlon = (core->getCurrentLocation().longitude)/Rad2Deg;
 	double currheight = (6371.+(core->getCurrentLocation().altitude)/1000.)/UA;
-	double currJD = core->getJDay();
+	double currJD = core->getJD();
 	double currJDint;
 //	GMTShift = StelUtils::getGMTShiftFromQT(currJD)/24.0;
 	GMTShift = StelApp::getInstance().getLocaleMgr().getGMTShift(currJD)/24.0;
@@ -302,7 +311,7 @@
 // NOW WE CHECK THE CHANGED PARAMETERS W.R.T. THE PREVIOUS FRAME:
 
 // Update JD.
-	myJD = currJD;
+	myJD.first = currJD;
 
 // If the year changed, we must recompute the Sun's position for each new day:
 	if (auxy != curYear)
@@ -494,12 +503,12 @@
 			
 			// Returns false if the calculation fails...
 			solvedMoon = calculateSolarSystemEvents(core, type);
-			currH = qAbs(24.*(MoonCulm-myJD)/TFrac);
-			transit = MoonCulm-myJD<0.0;
+			currH = qAbs(24.*(MoonCulm-myJD.first)/TFrac);
+			transit = MoonCulm-myJD.first<0.0;
 			if (solvedMoon)
 			{  // If failed, Set and Rise will be dummy.
-				settingTime = qAbs(24.*(MoonSet-myJD)/TFrac);
-				risingTime = qAbs(24.*(MoonRise-myJD)/TFrac);
+				settingTime = qAbs(24.*(MoonSet-myJD.first)/TFrac);
+				risingTime = qAbs(24.*(MoonRise-myJD.first)/TFrac);
 			}
 		}
 		else if (horizH>0.0)
@@ -947,7 +956,7 @@
 QString Observability::formatAsDate(int dayNumber)
 {
 	int day, month, year;
-	StelUtils::getDateFromJulianDay(yearJD[dayNumber], &year, &month, &day);
+	StelUtils::getDateFromJulianDay(yearJD[dayNumber].first, &year, &month, &day);
 
 	QString formatString = (getDateFormat()) ? "%1 %2" : "%2 %1";
 	QString result = formatString.arg(day).arg(monthNames[month-1]);
@@ -960,8 +969,8 @@
 {
 	int sDay, sMonth, sYear, eDay, eMonth, eYear;
 	QString range;
-	StelUtils::getDateFromJulianDay(yearJD[startDay], &sYear, &sMonth, &sDay);
-	StelUtils::getDateFromJulianDay(yearJD[endDay], &eYear, &eMonth, &eDay);
+	StelUtils::getDateFromJulianDay(yearJD[startDay].first, &sYear, &sMonth, &sDay);
+	StelUtils::getDateFromJulianDay(yearJD[endDay].first, &eYear, &eMonth, &eDay);
 	if (endDay == 0)
 	{
 		eDay = 31;
@@ -1017,7 +1026,7 @@
 {
 	int day, month, year, sameYear;
 // Get current date:
-	StelUtils::getDateFromJulianDay(myJD,&year,&month,&day);
+	StelUtils::getDateFromJulianDay(myJD.first,&year,&month,&day);
 
 // Get JD for the Jan 1 of current year:
 	StelUtils::getJDFromDate(&Jan1stJD,year,1,1,0,0,0);
@@ -1030,9 +1039,10 @@
 	Vec3d pos, sunPos;
 	for (int i=0; i<nDays; i++)
 	{
-		yearJD[i] = Jan1stJD + (double)i;
-		myEarth->computePosition(yearJD[i]);
-		myEarth->computeTransMatrix(yearJD[i]);
+		yearJD[i].first = Jan1stJD + (double)i;
+		yearJD[i].second = yearJD[i].first+core->computeDeltaT(yearJD[i].first)/86400.0;
+		myEarth->computePosition(yearJD[i].second);
+		myEarth->computeTransMatrix(yearJD[i].first, yearJD[i].second);
 		pos = myEarth->getHeliocentricEclipticPos();
 		sunPos = core->j2000ToEquinoxEqu((core->matVsop87ToJ2000)*(-pos));
 		EarthPos[i] = -pos;
@@ -1040,8 +1050,8 @@
 	};
 
 //Return the Earth to its current time:
-	myEarth->computePosition(myJD);
-	myEarth->computeTransMatrix(myJD);
+	myEarth->computePosition(myJD.second);
+	myEarth->computeTransMatrix(myJD.first, myJD.second);
 }
 ///////////////////////////////////////////////////
 
@@ -1261,24 +1271,24 @@
 //////////////////////////
 // Get the coordinates of Sun or Moon for a given JD:
 // getBack controls whether Earth and Moon must be returned to their original positions after computation.
-void Observability::getSunMoonCoords(StelCore *core, double jd,
-                                     double &raSun, double &decSun,
-                                     double &raMoon, double &decMoon,
-                                     double &eclLon, bool getBack) 
+void Observability::getSunMoonCoords(StelCore *core, QPair<double, double> JD,
+				     double &raSun, double &decSun,
+				     double &raMoon, double &decMoon,
+				     double &eclLon, bool getBack)
                                      //, Vec3d &AltAzVector)
 {
 
 	if (getBack) // Return the Moon and Earth to their current position:
 	{
-		myEarth->computePosition(jd);
-		myEarth->computeTransMatrix(jd);
-		myMoon->computePosition(jd);
-		myMoon->computeTransMatrix(jd);
+		myEarth->computePosition(JD.second);
+		myEarth->computeTransMatrix(JD.first, JD.second);
+		myMoon->computePosition(JD.second);
+		myMoon->computeTransMatrix(JD.first, JD.second);
 	} 
 	else // Compute coordinates:
 	{
-		myEarth->computePosition(jd);
-		myEarth->computeTransMatrix(jd);
+		myEarth->computePosition(JD.second);
+		myEarth->computeTransMatrix(JD.first, JD.second);
 		Vec3d earthPos = myEarth->getHeliocentricEclipticPos();
 		double curSidT;
 
@@ -1287,11 +1297,11 @@
 		toRADec(sunPos, raSun, decSun);
 
 // Moon coordinates:
-		curSidT = myEarth->getSiderealTime(jd)/Rad2Deg;
+		curSidT = myEarth->getSiderealTime(JD.first, JD.second)/Rad2Deg;
 		RotObserver = (Mat4d::zrotation(curSidT))*ObserverLoc;
 		LocTrans = (core->matVsop87ToJ2000)*(Mat4d::translation(-earthPos));
-		myMoon->computePosition(jd);
-		myMoon->computeTransMatrix(jd);
+		myMoon->computePosition(JD.second);
+		myMoon->computeTransMatrix(JD.first, JD.second);
 		Vec3d moonPos = myMoon->getHeliocentricEclipticPos();
 		sunPos = (core->j2000ToEquinoxEqu(LocTrans*moonPos))-RotObserver;
 		
@@ -1307,20 +1317,20 @@
 //////////////////////////
 // Get the Observer-to-Moon distance JD:
 // getBack controls whether Earth and Moon must be returned to their original positions after computation.
-void Observability::getMoonDistance(StelCore *core, double jd, double &distance, bool getBack)
+void Observability::getMoonDistance(StelCore *core, QPair<double, double> JD, double &distance, bool getBack)
 {
 
 	if (getBack) // Return the Moon and Earth to their current position:
 	{
-		myEarth->computePosition(jd);
-		myEarth->computeTransMatrix(jd);
-		myMoon->computePosition(jd);
-		myMoon->computeTransMatrix(jd);
+		myEarth->computePosition(JD.second);
+		myEarth->computeTransMatrix(JD.first, JD.second);
+		myMoon->computePosition(JD.second);
+		myMoon->computeTransMatrix(JD.first, JD.second);
 	} 
 	else
 	{	// Compute coordinates:
-		myEarth->computePosition(jd);
-		myEarth->computeTransMatrix(jd);
+		myEarth->computePosition(JD.second);
+		myEarth->computeTransMatrix(JD.first, JD.second);
 		Vec3d earthPos = myEarth->getHeliocentricEclipticPos();
 //		double curSidT;
 
@@ -1332,8 +1342,8 @@
 //		curSidT = myEarth->getSiderealTime(JD)/Rad2Deg;
 //		RotObserver = (Mat4d::zrotation(curSidT))*ObserverLoc;
 		LocTrans = (core->matVsop87ToJ2000)*(Mat4d::translation(-earthPos));
-		myMoon->computePosition(jd);
-		myMoon->computeTransMatrix(jd);
+		myMoon->computePosition(JD.second);
+		myMoon->computeTransMatrix(JD.first, JD.second);
 		Pos1 = myMoon->getHeliocentricEclipticPos();
 		Pos2 = (core->j2000ToEquinoxEqu(LocTrans*Pos1)); //-RotObserver;
 
@@ -1349,24 +1359,24 @@
 
 //////////////////////////////////////////////
 // Get the Coords of a planet:
-void Observability::getPlanetCoords(StelCore *core, double JD, double &RA, double &Dec, bool getBack)
+void Observability::getPlanetCoords(StelCore *core, QPair<double, double> JD, double &RA, double &Dec, bool getBack)
 {
 
 	if (getBack)
 	{
 	// Return the planet to its current time:
-		myPlanet->computePosition(JD);
-		myPlanet->computeTransMatrix(JD);
-		myEarth->computePosition(JD);
-		myEarth->computeTransMatrix(JD);
+		myPlanet->computePosition(JD.second);
+		myPlanet->computeTransMatrix(JD.first, JD.second);
+		myEarth->computePosition(JD.second);
+		myEarth->computeTransMatrix(JD.first, JD.second);
 	} else
 	{
 	// Compute planet's position:
-		myPlanet->computePosition(JD);
-		myPlanet->computeTransMatrix(JD);
+		myPlanet->computePosition(JD.second);
+		myPlanet->computeTransMatrix(JD.first, JD.second);
 		Pos1 = myPlanet->getHeliocentricEclipticPos();
-		myEarth->computePosition(JD);
-		myEarth->computeTransMatrix(JD);
+		myEarth->computePosition(JD.second);
+		myEarth->computeTransMatrix(JD.first, JD.second);
 		Pos2 = myEarth->getHeliocentricEclipticPos();
 		LocTrans = (core->matVsop87ToJ2000)*(Mat4d::translation(-Pos2));
 		Pos2 = core->j2000ToEquinoxEqu(LocTrans*Pos1);
@@ -1385,7 +1395,8 @@
 
 	const int NUM_ITER = 100;
 	int i;
-	double hHoriz, ra, dec, raSun, decSun, tempH, tempJd, tempEphH, curSidT, eclLon;
+	double hHoriz, ra, dec, raSun, decSun, tempH, /* tempJd, */ tempEphH, curSidT, eclLon;
+	QPair<double, double> tempJd;
 	//Vec3d Observer;
 
 	hHoriz = calculateHourAngle(mylat, refractedHorizonAlt, selDec);
@@ -1394,15 +1405,15 @@
 
 // Only recompute ephemeris from second to second (at least)
 // or if the source has changed (i.e., Sun <-> Moon). This saves resources:
-	if (qAbs(myJD-lastJDMoon)>JDsec || lastType!=bodyType || souChanged)
+	if (qAbs(myJD.first-lastJDMoon)>JDsec || lastType!=bodyType || souChanged)
 	{
 
 //		qDebug() << q_("%1  %2   %3   %4").arg(Kind).arg(LastObject).arg(myJD,0,'f',5).arg(lastJDMoon,0,'f',5);
 
 		lastType = bodyType;
 
-		myEarth->computePosition(myJD);
-		myEarth->computeTransMatrix(myJD);
+		myEarth->computePosition(myJD.second);
+		myEarth->computeTransMatrix(myJD.first, myJD.second);
 		Vec3d earthPos = myEarth->getHeliocentricEclipticPos();
 
 		if (bodyType == 1) // Sun position
@@ -1411,18 +1422,18 @@
 		}
 		else if (bodyType==2) // Moon position
 		{
-			curSidT = myEarth->getSiderealTime(myJD)/Rad2Deg;
+			curSidT = myEarth->getSiderealTime(myJD.first, myJD.second)/Rad2Deg;
 			RotObserver = (Mat4d::zrotation(curSidT))*ObserverLoc;
 			LocTrans = (core->matVsop87ToJ2000)*(Mat4d::translation(-earthPos));
-			myMoon->computePosition(myJD);
-			myMoon->computeTransMatrix(myJD);
+			myMoon->computePosition(myJD.second);
+			myMoon->computeTransMatrix(myJD.first, myJD.second);
 			Pos1 = myMoon->getHeliocentricEclipticPos();
 			Pos2 = (core->j2000ToEquinoxEqu(LocTrans*Pos1))-RotObserver;
 		}
 		else // Planet position
 		{
-			myPlanet->computePosition(myJD);
-			myPlanet->computeTransMatrix(myJD);
+			myPlanet->computePosition(myJD.second);
+			myPlanet->computeTransMatrix(myJD.first, myJD.second);
 			Pos1 = myPlanet->getHeliocentricEclipticPos();
 			LocTrans = (core->matVsop87ToJ2000)*(Mat4d::translation(-earthPos));
 			Pos2 = core->j2000ToEquinoxEqu(LocTrans*Pos1);
@@ -1452,11 +1463,12 @@
 
 // Rise time:
 			tempEphH = MoonRise*TFrac;
-			MoonRise = myJD + (MoonRise/24.);
+			MoonRise = myJD.first + (MoonRise/24.);
 			for (i=0; i<NUM_ITER; i++)
 			{
 	// Get modified coordinates:
-				tempJd = MoonRise;
+				tempJd.first = MoonRise;
+				tempJd.second=tempJd.first+core->computeDeltaT(tempJd.first)/86400.0;
 	
 				if (bodyType<3)
 				{
@@ -1485,16 +1497,18 @@
 				if (qAbs(tempH-tempEphH)<JDsec) break;
 			// Update rise-time estimate:
 				tempEphH = tempH;
-				MoonRise = myJD + (tempEphH/24.);
+				MoonRise = myJD.first + (tempEphH/24.);
 			};
 
 // Set time:  
 			tempEphH = MoonSet;
-			MoonSet = myJD + (MoonSet/24.);
+			MoonSet = myJD.first + (MoonSet/24.);
 			for (i=0; i<NUM_ITER; i++)
 			{
 	// Get modified coordinates:
-				tempJd = MoonSet;
+				tempJd.first = MoonSet;
+				tempJd.second=tempJd.first+core->computeDeltaT(tempJd.first)/86400.0;
+
 				
 				if (bodyType < 3)
 					getSunMoonCoords(core, tempJd,
@@ -1521,7 +1535,7 @@
 					break;
 		// Update set-time estimate:
 				tempEphH = tempH;
-				MoonSet = myJD + (tempEphH/24.);
+				MoonSet = myJD.first + (tempEphH/24.);
 			};
 		} 
 		else // Comes from if(raises)
@@ -1532,12 +1546,14 @@
 
 // Culmination time:
 		tempEphH = MoonCulm;
-		MoonCulm = myJD + (MoonCulm/24.);
+		MoonCulm = myJD.first + (MoonCulm/24.);
 
 		for (i=0; i<NUM_ITER; i++)
 		{
 			// Get modified coordinates:
-			tempJd = MoonCulm;
+			tempJd.first = MoonCulm;
+			tempJd.second=tempJd.first+core->computeDeltaT(tempJd.first)/86400.0;
+
 
 			if (bodyType<3)
 			{
@@ -1561,16 +1577,16 @@
 	// Check convergence:
 			if (qAbs(tempH-tempEphH)<JDsec) break;
 			tempEphH = tempH;
-			MoonCulm = myJD + (tempEphH/24.);
+			MoonCulm = myJD.first + (tempEphH/24.);
 			culmAlt = qAbs(mylat-dec); // 90 - altitude at transit.
 		};
 
 //		qDebug() << q_("%1").arg(MoonCulm,0,'f',5);
 
 
-	lastJDMoon = myJD;
+	lastJDMoon = myJD.first;
 
-	}; // Comes from if (qAbs(myJD-lastJDMoon)>JDsec || LastObject!=Kind)
+	}; // Comes from if (qAbs(myJD.first-lastJDMoon)>JDsec || LastObject!=Kind)
 
 
 
@@ -1580,13 +1596,13 @@
 	{
 
 	// Only estimate date of Full Moon if we have changed Lunar month:
-		if (myJD > nextFullMoon || myJD < prevFullMoon)
+		if (myJD.first > nextFullMoon || myJD.first < prevFullMoon)
 		{
 
 
 	// Estimate the nearest (in time) Full Moon:
 			double nT;
-			double dT = std::modf((myJD-RefFullMoon)/MoonT,&nT);
+			double dT = std::modf((myJD.first-RefFullMoon)/MoonT,&nT);
 			if (dT>0.5) {nT += 1.0;};
 			if (dT<-0.5) {nT -= 1.0;};
 
@@ -1596,7 +1612,8 @@
 
 			dT = 0.1/1440.; // 6 seconds. Our time span for the finite-difference derivative estimate.
 //			double Deriv1, Deriv2; // Variables for temporal use.
-			double Sec1, Sec2, Temp1, Temp2; // Variables for temporal use.
+			QPair<double, double>Sec1, Sec2; // Variables for temporal use. Contrary to the other cases, we have Sec[12].second=DeltaT[days], not JDE. This avoids needless re-computing.
+			double Temp1, Temp2; // Variables for temporal use.
 			double iniEst1, iniEst2;  // JD values that MUST include the solution within them.
 			double Phase1;
 
@@ -1606,26 +1623,31 @@
 				iniEst1 =  TempFullMoon - 0.25*MoonT; 
 				iniEst2 =  TempFullMoon + 0.25*MoonT; 
 
-				Sec1 = iniEst1; // TempFullMoon - 0.05*MoonT; // Initial estimates of Full-Moon dates
-				Sec2 = iniEst2; // TempFullMoon + 0.05*MoonT; 
-
-				getSunMoonCoords(core,Sec1,raSun,decSun,ra,dec,eclLon,false);
+
+				Sec1.first = iniEst1; // TempFullMoon - 0.05*MoonT; // Initial estimates of Full-Moon dates
+				Sec1.second= core->computeDeltaT(Sec1.first)/86400.0; // enough to compute this once.
+				Sec2.first = iniEst2; // TempFullMoon + 0.05*MoonT;
+				Sec2.second= core->computeDeltaT(Sec2.first)/86400.0; // enough to compute this once.
+
+				// for the computation calls, we need temporary QPairs here!
+				getSunMoonCoords(core,QPair<double, double>(Sec1.first, Sec1.first+Sec1.second),raSun,decSun,ra,dec,eclLon,false);
 				Temp1 = eclLon; //Lambda(RA,Dec,RAS,DecS);
-				getSunMoonCoords(core,Sec2,raSun,decSun,ra,dec,eclLon,false);
+				getSunMoonCoords(core,QPair<double, double>(Sec2.first, Sec2.first+Sec2.second),raSun,decSun,ra,dec,eclLon,false);
 				Temp2 = eclLon; //Lambda(RA,Dec,RAS,DecS);
 
 
 				for (int i=0; i<100; i++) // A limit of 100 iterations.
 				{
-					Phase1 = (Sec2-Sec1)/(Temp1-Temp2)*Temp1+Sec1;
-					getSunMoonCoords(core,Phase1,raSun,decSun,ra,dec,eclLon,false);
+					Phase1 = (Sec2.first-Sec1.first)/(Temp1-Temp2)*Temp1+Sec1.first;
+					// The ad-hoc pair needs a DeltaT, use the one of Sec1
+					getSunMoonCoords(core,QPair<double, double>(Phase1, Phase1+Sec1.second),raSun,decSun,ra,dec,eclLon,false);
 					
 					if (Temp1*eclLon < 0.0) 
 					{
-						Sec2 = Phase1;
+						Sec2.first = Phase1;
 						Temp2 = eclLon;
 					} else {
-						Sec1 = Phase1;
+						Sec1.first = Phase1;
 						Temp1 = eclLon;
 
 					};
@@ -1633,9 +1655,9 @@
 				//	qDebug() << QString("%1 %2 %3 %4 ").arg(Sec1).arg(Sec2).arg(Temp1).arg(Temp2);	
 
 
-					if (qAbs(Sec2-Sec1) < 10.*dT)  // 1 minute accuracy; convergence.
+					if (qAbs(Sec2.first-Sec1.first) < 10.*dT)  // 1 minute accuracy; convergence.
 					{
-						TempFullMoon = (Sec1+Sec2)/2.;
+						TempFullMoon = (Sec1.first+Sec2.first)/2.;
 				//		qDebug() << QString("%1%2 ").arg(TempFullMoon);	
 						break;
 					};
@@ -1643,7 +1665,7 @@
 				};
 
 
-				if (TempFullMoon > myJD) 
+				if (TempFullMoon > myJD.first)
 				{
 					nextFullMoon = TempFullMoon;
 					TempFullMoon -= MoonT;

=== modified file 'plugins/Observability/src/Observability.hpp'
--- plugins/Observability/src/Observability.hpp	2015-05-30 19:56:47 +0000
+++ plugins/Observability/src/Observability.hpp	2015-08-03 13:17:13 +0000
@@ -21,6 +21,7 @@
 #include "StelModule.hpp"
 #include <QFont>
 #include <QString>
+#include <QPair>
 #include "VecMath.hpp"
 #include "SolarSystem.hpp"
 #include "Planet.hpp"
@@ -190,33 +191,33 @@
 
 //! Computes the Sun or Moon coordinates at a given Julian date.
 //! @param core the stellarium core.
-//! @param JD double for the Julian date.
+//! @param JD QPair of double for the Julian date: first=JD_UT and .second=JDE_DT
 //! @param RASun right ascension of the Sun (in hours).
 //! @param DecSun declination of the Sun (in radians).
 //! @param RAMoon idem for the Moon.
 //! @param DecMoon idem for the Moon.
 //! @param EclLon is the module of the vector product of Heliocentric Ecliptic Coordinates of Sun and Moon (projected over the Ecliptic plane). Useful to derive the dates of Full Moon.
 //! @param getBack controls whether Earth and Moon must be returned to their original positions after computation.
-	void getSunMoonCoords(StelCore* core, double jd,
-	                      double& raSun, double& decSun,
-	                      double& raMoon, double& decMoon,
-	                      double& eclLon, bool getBack);
+	void getSunMoonCoords(StelCore* core, QPair<double, double> JD,
+			      double& raSun, double& decSun,
+			      double& raMoon, double& decMoon,
+			      double& eclLon, bool getBack);
 
 
 //! computes the selected-planet coordinates at a given Julian date.
 //! @param core the stellarium core.
-//! @param JD double for the Julian date.
+//! @param JD QPair for the Julian date: .first=JD(UT), .second=JDE
 //! @param RA right ascension of the planet (in hours).
 //! @param Dec declination of the planet (in radians).
 //! @param getBack controls whether the planet must be returned to its original positions after computation.
-	void getPlanetCoords(StelCore* core, double JD, double &RA, double &Dec, bool getBack);
+	void getPlanetCoords(StelCore* core, QPair<double, double> JD, double &RA, double &Dec, bool getBack);
 
-//! Comptues the Earth-Moon distance (in AU) at a given Julian date.
-//! The parameters are similar to those of getSunMoonCoords or getPlanetCoords.
+//! Computes the Earth-Moon distance (in AU) at a given Julian date.
+//! The parameters are similar to those of getSunMoonCoords() or getPlanetCoords().
 	void getMoonDistance(StelCore* core,
-	                     double jd,
-	                     double& distance,
-	                     bool getBack);
+			     QPair<double, double> JD,
+			     double& distance,
+			     bool getBack);
 
 //! Returns the angular separation (in radians) between two points.
 //! @param RA1 right ascension of point 1 (in hours)
@@ -268,15 +269,19 @@
 	void toRADec(Vec3d vec3d, double& ra, double& dec);
 
 	//! Table containing the Julian Dates of the days of the current year.
-	double yearJD[366];
+	QPair<double, double> yearJD[366]; // GZ: This had to become a QPair of JD.first=JD_UT, JD.second=JDE
 
 //! Check if a source is observable during a given date.
 //! @param i the day of the year.
 	bool CheckRise(int day);
 
-//! Some useful constants and variables(almost self-explanatory).
-	double Rad2Deg, Rad2Hr, UA, TFrac, JDsec, Jan1stJD, halfpi, MoonT, nextFullMoon, prevFullMoon, RefFullMoon, GMTShift, MoonPerilune;
-	
+//! Some useful constants (almost self-explanatory).
+// GZ: Made true constants out of those, and improved accuracy of some.
+	static const double Rad2Deg, Rad2Hr, UA, TFrac, JDsec, halfpi, MoonT, RefFullMoon, MoonPerilune;
+
+//! Some useful variables(almost self-explanatory).
+	double nextFullMoon, prevFullMoon, GMTShift, Jan1stJD;
+
 	//! User-defined angular altitude of astronomical twilight in radians.
 	//! See setTwilightAltitude() and getTwilightAltitude().
 	double twilightAltRad;
@@ -292,7 +297,9 @@
 	int horizonAltDeg;
 
 //! RA, Dec, observer latitude, object's elevation, and Hour Angle at horizon.
-	double selRA, selDec, mylat, mylon, alti, horizH, culmAlt, myJD;
+	double selRA, selDec, mylat, mylon, alti, horizH, culmAlt;
+//! Some place to keep JD and JDE. .first is JD(UT), .second is for the fitting JDE.
+	QPair<double, double> myJD;
 
 //! Vectors to store Sun's RA, Dec, and Sid. Time at twilight and rise/set.
 	double sunRA[366];
@@ -304,7 +311,7 @@
 	double objectRA[366]; 
 	double objectDec[366];
 	double objectH0[366];
-	//! Table of the sidereal time of the object's rising/setting. 
+//! Table of the sidereal time of the object's rising/setting.
 	double objectSidT[2][366];
 
 //! Rise/Set/Transit times for the Moon at current day:

=== modified file 'plugins/PointerCoordinates/src/PointerCoordinates.cpp'
--- plugins/PointerCoordinates/src/PointerCoordinates.cpp	2015-04-24 17:04:28 +0000
+++ plugins/PointerCoordinates/src/PointerCoordinates.cpp	2015-08-03 13:17:13 +0000
@@ -210,7 +210,7 @@
 		{
 			double lambda, beta;
 			StelUtils::rectToSphe(&cx,&cy,core->j2000ToEquinoxEqu(mousePosition));
-			StelUtils::equToEcl(cx, cy, core->getCurrentPlanet()->getRotObliquity(core->getJDay()), &lambda, &beta); // Calculate ecliptic position and show it...
+			StelUtils::equToEcl(cx, cy, core->getCurrentPlanet()->getRotObliquity(core->getJDE()), &lambda, &beta); // Calculate ecliptic position and show it...
 			if (lambda<0) lambda+=2.0*M_PI;
 			coordsSystem = qc_("Ecl. Long/Lat", "abbreviated in the plugin");
 			if (withDecimalDegree)
@@ -247,7 +247,7 @@
 		case HourAngle:
 		{
 			Vec3d v = core->j2000ToAltAz(mousePosition, StelCore::RefractionAuto);
-			StelUtils::rectToSphe(&cx,&cy,Mat4d::zrotation(-core->getLocalSiderealTime()+((core->getDeltaT(core->getJDay())/240.)*M_PI/180.))*core->altAzToEquinoxEqu(v, StelCore::RefractionOff));
+			StelUtils::rectToSphe(&cx,&cy,Mat4d::zrotation(-core->getLocalSiderealTime())*core->altAzToEquinoxEqu(v, StelCore::RefractionOff));
 			cx = 2.*M_PI-cx;
 			coordsSystem = qc_("HA/Dec", "abbreviated in the plugin");
 			if (withDecimalDegree)

=== modified file 'plugins/Satellites/src/Satellite.cpp'
--- plugins/Satellites/src/Satellite.cpp	2015-06-18 19:50:02 +0000
+++ plugins/Satellites/src/Satellite.cpp	2015-08-03 13:17:13 +0000
@@ -612,8 +612,7 @@
 	if (pSatWrapper && orbitValid)
 	{
 		StelCore* core = StelApp::getInstance().getCore();
-		double JD = core->getJDay();
-		epochTime = JD - core->getDeltaT(JD)/86400; // Delta T anti-correction for artificial satellites
+		epochTime = core->getJD(); // We have "true" JD from core, satellites don't need JDE!
 
 		pSatWrapper->setEpoch(epochTime);
 		position                 = pSatWrapper->getTEMEPos();
@@ -730,7 +729,7 @@
 
 void Satellite::draw(StelCore* core, StelPainter& painter, float)
 {
-	if (core->getJDay()<jdLaunchYearJan1 || !displayed)
+	if (core->getJD()<jdLaunchYearJan1 || !displayed)
 		return;
 
 	XYZ = getJ2000EquatorialPos(core);

=== modified file 'plugins/Satellites/src/Satellites.cpp'
--- plugins/Satellites/src/Satellites.cpp	2015-06-17 18:00:57 +0000
+++ plugins/Satellites/src/Satellites.cpp	2015-08-03 13:17:13 +0000
@@ -1694,7 +1694,7 @@
 bool Satellites::isValidRangeDates() const
 {
 	bool ok;
-	double tJD = StelApp::getInstance().getCore()->getJDay();
+	double tJD = StelApp::getInstance().getCore()->getJD();
 	double uJD = StelUtils::getJulianDayFromISO8601String(lastUpdate.toString(Qt::ISODate), &ok);
 	if (lastUpdate.isNull()) // No updates yet?
 		uJD = tJD;

=== modified file 'plugins/Satellites/src/gSatWrapper.cpp'
--- plugins/Satellites/src/gSatWrapper.cpp	2015-02-01 20:44:54 +0000
+++ plugins/Satellites/src/gSatWrapper.cpp	2015-08-03 13:17:13 +0000
@@ -122,7 +122,7 @@
 
 void gSatWrapper::updateEpoch()
 {
-	double jul_utc = StelApp::getInstance().getCore()->getJDay();
+	double jul_utc = StelApp::getInstance().getCore()->getJD();
         epoch = jul_utc;
 
 	if (pSatellite)

=== modified file 'plugins/Satellites/src/gsatellite/gVector.cpp'
--- plugins/Satellites/src/gsatellite/gVector.cpp	2015-02-01 20:44:54 +0000
+++ plugins/Satellites/src/gsatellite/gVector.cpp	2015-08-03 13:17:13 +0000
@@ -34,7 +34,7 @@
 
 }
 
-gVector::gVector(unsigned int ai_uiElementsNumber)
+gVector::gVector(size_t ai_uiElementsNumber)
 	: br_stl::gVectorTempl<double>(ai_uiElementsNumber)
 {
 

=== modified file 'plugins/Satellites/src/gsatellite/gVector.hpp'
--- plugins/Satellites/src/gsatellite/gVector.hpp	2015-05-30 19:56:47 +0000
+++ plugins/Satellites/src/gsatellite/gVector.hpp	2015-08-03 13:17:13 +0000
@@ -43,9 +43,10 @@
 
 public:
 	gVector();
-	gVector(unsigned int ai_uiElementsNumber);
+	//gVector(unsigned int ai_uiElementsNumber);
+	gVector(size_t ai_uiElementsNumber);
 
-	virtual ~gVector() {};
+	virtual ~gVector() {}
 
 	//## Other Operations (specified)
 	//## Operation: operator*

=== modified file 'plugins/Scenery3d/src/Scenery3d.cpp'
--- plugins/Scenery3d/src/Scenery3d.cpp	2015-05-18 12:01:39 +0000
+++ plugins/Scenery3d/src/Scenery3d.cpp	2015-08-03 13:17:13 +0000
@@ -391,7 +391,7 @@
 				movement[2]);
 
 		//get current time
-		double curTime = core->getJDay();
+		double curTime = core->getJD();
 
 		if(lazyDrawing)
 		{
@@ -1542,7 +1542,7 @@
 
 	if(needsCubemapUpdate)
 	{
-		lastCubemapUpdate = core->getJDay();
+		lastCubemapUpdate = core->getJD();
 		lastCubemapUpdateRealTime = QDateTime::currentMSecsSinceEpoch();
 	}
 }
@@ -1893,7 +1893,7 @@
 	    str = QString("Last cubemap update: %1ms ago").arg(QDateTime::currentMSecsSinceEpoch() - lastCubemapUpdateRealTime);
 	    painter.drawText(screen_x, screen_y, str);
 	    screen_y -= 15.0f;
-	    str = QString("Last cubemap update JDAY: %1").arg(qAbs(core->getJDay()-lastCubemapUpdate) * StelCore::ONE_OVER_JD_SECOND);
+	    str = QString("Last cubemap update JDAY: %1").arg(qAbs(core->getJD()-lastCubemapUpdate) * StelCore::ONE_OVER_JD_SECOND);
 	    painter.drawText(screen_x, screen_y, str);
     }
 

=== modified file 'plugins/Supernovae/src/Supernova.cpp'
--- plugins/Supernovae/src/Supernova.cpp	2015-02-08 15:35:27 +0000
+++ plugins/Supernovae/src/Supernova.cpp	2015-08-03 13:17:13 +0000
@@ -160,7 +160,7 @@
 float Supernova::getVMagnitude(const StelCore* core) const
 {
 	double vmag = 20;
-	double currentJD = core->getJDay();
+	double currentJD = core->getJDE(); // GZ JDfix for 0.14. I hope the JD in the list is JDE? (Usually difference should be negligible)
 	double deltaJD = qAbs(peakJD-currentJD);
 
 	// Use supernova light curve model from here - http://www.astronet.ru/db/msg/1188703

=== modified file 'plugins/TelescopeControl/src/clients/TelescopeClient.cpp'
--- plugins/TelescopeControl/src/clients/TelescopeClient.cpp	2015-02-05 15:44:10 +0000
+++ plugins/TelescopeControl/src/clients/TelescopeClient.cpp	2015-08-03 13:17:13 +0000
@@ -146,7 +146,7 @@
 // At the moment this can't be done in a platform-independent way with Qt
 // (QDateTime and QTime don't support microsecond precision)
 	qint64 t;
-	StelCore *core = StelApp::getInstance().getCore();
+	//StelCore *core = StelApp::getInstance().getCore();
 #ifdef Q_OS_WIN32
 	FILETIME file_time;
 	GetSystemTimeAsFileTime(&file_time);
@@ -156,7 +156,9 @@
 	gettimeofday(&tv,0);
 	t = tv.tv_sec * 1000000LL + tv.tv_usec;
 #endif
-	return t - core->getDeltaT(StelUtils::getJDFromSystem())*1000000; // Delta T anti-correction
+	// GZ JDfix for 0.14 I am 99.9% sure we no longer need the anti-correction
+	//return t - core->getDeltaT(StelUtils::getJDFromSystem())*1000000; // Delta T anti-correction
+	return t;
 }
 
 TelescopeTCP::TelescopeTCP(const QString &name, const QString &params, Equinox eq)

=== modified file 'plugins/TelescopeControl/src/servers/Socket.cpp'
--- plugins/TelescopeControl/src/servers/Socket.cpp	2013-05-15 12:54:31 +0000
+++ plugins/TelescopeControl/src/servers/Socket.cpp	2015-08-03 13:17:13 +0000
@@ -36,7 +36,7 @@
 long long int GetNow(void)
 {
 	long long int t;
-	StelCore *core = StelApp::getInstance().getCore();
+	//StelCore *core = StelApp::getInstance().getCore();
 #ifdef Q_OS_WIN32
 	union
 	{
@@ -50,7 +50,9 @@
 	gettimeofday(&tv, 0);
 	t = tv.tv_sec * 1000000LL + tv.tv_usec;
 #endif
-	return t - core->getDeltaT(StelUtils::getJDFromSystem())*1000000; // Delta T anti-correction
+	// GZ JDfix for 0.14 I am 99.9% sure we no longer need the anti-correction
+	//return t - core->getDeltaT(StelUtils::getJDFromSystem())*1000000; // Delta T anti-correction
+	return t;
 }
 
 void Socket::hangup(void)

=== modified file 'plugins/TextUserInterface/src/TextUserInterface.cpp'
--- plugins/TextUserInterface/src/TextUserInterface.cpp	2015-06-14 20:40:29 +0000
+++ plugins/TextUserInterface/src/TextUserInterface.cpp	2015-08-03 13:17:13 +0000
@@ -174,8 +174,8 @@
 	m1->setNextNode(m2);
 	TuiNode* m2_1 = new TuiNodeDateTime(N_("Current date/time"),
 	                                    core,
-	                                    SLOT(setJDay(double)),  
-	                                    core->getJDay(),
+					    SLOT(setJD(double)),
+					    core->getJD(),
 	                                    m2);
 	TuiNode* m2_2 = new TuiNode(N_("Set time zone"), m2, m2_1);
 	TuiNode* m2_3 = new TuiNode(N_("Day keys"), m2, m2_2);
@@ -605,7 +605,7 @@
 
 	if (tuiDateTime) 
 	{
-		double jd = core->getJDay();
+		double jd = core->getJD();
 		int text_x = x + xVc*2/3, text_y = y + pixOffset;
 
 		QString newDate = StelApp::getInstance().getLocaleMgr().getPrintableDateLocal(jd) + "   "

=== modified file 'src/core/StelCore.cpp'
--- src/core/StelCore.cpp	2015-08-02 17:12:29 +0000
+++ src/core/StelCore.cpp	2015-08-03 13:17:13 +0000
@@ -50,11 +50,11 @@
 const Mat4d StelCore::matJ2000ToGalactic(-0.054875539726, 0.494109453312, -0.867666135858, 0, -0.873437108010, -0.444829589425, -0.198076386122, 0, -0.483834985808, 0.746982251810, 0.455983795705, 0, 0, 0, 0, 1);
 const Mat4d StelCore::matGalacticToJ2000(matJ2000ToGalactic.transpose());
 
-const double StelCore::JD_SECOND=0.000011574074074074074074;
-const double StelCore::JD_MINUTE=0.00069444444444444444444;
-const double StelCore::JD_HOUR  =0.041666666666666666666;
+const double StelCore::JD_SECOND=0.000011574074074074074074; // 1/(24*60*60)=1/86400
+const double StelCore::JD_MINUTE=0.00069444444444444444444;  // 1/(24*60)   =1/1440
+const double StelCore::JD_HOUR  =0.041666666666666666666;    // 1/24
 const double StelCore::JD_DAY   =1.;
-const double StelCore::ONE_OVER_JD_SECOND = 24 * 60 * 60;
+const double StelCore::ONE_OVER_JD_SECOND = 24 * 60 * 60;    // 86400
 
 
 StelCore::StelCore()
@@ -65,10 +65,10 @@
 	, currentDeltaTAlgorithm(EspenakMeeus)
 	, position(NULL)
 	, timeSpeed(JD_SECOND)
-	, JDay(0.)
+	, JD(0.,0.)
 	, presetSkyTime(0.)
-	, secondsOfLastJDayUpdate(0.)
-	, JDayOfLastJDayUpdate(0.)
+	, secondsOfLastJDUpdate(0.)
+	, jdOfLastJDUpdate(0.)
 	, deltaTCustomNDot(-26.0)
 	, deltaTCustomYear(1820.0)
 {
@@ -173,7 +173,7 @@
 	setInitTodayTime(QTime::fromString(conf->value("navigation/today_time", "22:00").toString()));
 	startupTimeMode = conf->value("navigation/startup_time_mode", "actual").toString().toLower();
 	if (startupTimeMode=="preset")	
-		setJDay(presetSkyTime - StelUtils::getGMTShiftFromQT(presetSkyTime) * JD_HOUR);
+		setJD(presetSkyTime - StelUtils::getGMTShiftFromQT(presetSkyTime) * JD_HOUR);
 	else if (startupTimeMode=="today")
 		setTodayTime(getInitTodayTime());
 
@@ -766,7 +766,7 @@
 // called in update() (for every frame)
 void StelCore::updateTransformMatrices()
 {
-	matAltAzToEquinoxEqu = position->getRotAltAzToEquatorial(JDay);
+	matAltAzToEquinoxEqu = position->getRotAltAzToEquatorial(getJD(), getJDE());
 	matEquinoxEquToAltAz = matAltAzToEquinoxEqu.transpose();
 
 	// multiply static J2000 earth axis tilt (eclipticalJ2000<->equatorialJ2000)
@@ -865,26 +865,40 @@
 	smmgr->zoomTo(smmgr->getInitFov(), 1.);
 }
 
-void StelCore::setJDay(double JD)
-{
-	JDay=JD;
-	resetSync();
-}
-
-double StelCore::getJDay() const
-{
-	return JDay;
-}
+void StelCore::setJD(double newJD)
+{
+	JD.first=newJD;
+	JD.second=computeDeltaT(newJD);
+	resetSync();
+}
+
+double StelCore::getJD() const
+{
+	return JD.first;
+}
+
+void StelCore::setJDE(double newJDE)
+{
+	// nitpickerish this is not exact, but as good as it gets...
+	JD.second=computeDeltaT(newJDE);
+	JD.first=newJDE-JD.second/86400.0;
+	resetSync();
+}
+
+double StelCore::getJDE() const
+{
+	return JD.first+JD.second/86400.0;
+}
+
 
 void StelCore::setMJDay(double MJD)
 {
-	JDay=MJD+2400000.5;
-	resetSync();
+	setJD(MJD+2400000.5);
 }
 
 double StelCore::getMJDay() const
 {
-	return JDay-2400000.5;
+	return JD.first-2400000.5;
 }
 
 double StelCore::getPresetSkyTime() const
@@ -993,9 +1007,7 @@
 //! Set stellarium time to current real world time
 void StelCore::setTimeNow()
 {
-	double JD = StelUtils::getJDFromSystem();
-	// add Delta-T correction for actual time
-	setJDay(JD+getDeltaT(JD)/86400);
+	setJD(StelUtils::getJDFromSystem());
 }
 
 void StelCore::setTodayTime(const QTime& target)
@@ -1006,7 +1018,7 @@
 		dt.setTime(target);
 		// don't forget to adjust for timezone / daylight savings.
 		double JD = StelUtils::qDateTimeToJd(dt)-(StelUtils::getGMTShiftFromQT(StelUtils::getJDFromSystem()) * JD_HOUR);
-		setJDay(JD + getDeltaT(JD)/86400);
+		setJD(JD);
 	}
 	else
 	{
@@ -1019,12 +1031,12 @@
 bool StelCore::getIsTimeNow(void) const
 {
 	// cache last time to prevent to much slow system call
-	static double lastJD = getJDay();
-	static bool previousResult = (fabs(getJDay()-(StelUtils::getJDFromSystem()+getDeltaT(lastJD)/86400))<JD_SECOND);
-	if (fabs(lastJD-getJDay())>JD_SECOND/4)
+	static double lastJD = getJD();
+	static bool previousResult = (fabs(getJD()-(StelUtils::getJDFromSystem()))<JD_SECOND);
+	if (fabs(lastJD-getJD())>JD_SECOND/4)
 	{
-		lastJD = getJDay();
-		previousResult = (fabs(getJDay()-(StelUtils::getJDFromSystem()+getDeltaT(lastJD)/86400))<JD_SECOND);
+		lastJD = getJD();
+		previousResult = (fabs(getJD()-(StelUtils::getJDFromSystem()))<JD_SECOND);
 	}
 	return previousResult;
 }
@@ -1034,14 +1046,14 @@
 	return initTodayTime;
 }
 
-void StelCore::setInitTodayTime(const QTime& t)
+void StelCore::setInitTodayTime(const QTime& time)
 {
-	initTodayTime=t;
+	initTodayTime=time;
 }
 
-void StelCore::setPresetSkyTime(QDateTime dt)
+void StelCore::setPresetSkyTime(QDateTime dateTime)
 {
-	setPresetSkyTime(StelUtils::qDateTimeToJd(dt));
+	setPresetSkyTime(StelUtils::qDateTimeToJd(dateTime));
 }
 
 void StelCore::addHour()
@@ -1250,7 +1262,7 @@
 	if (home->getEnglishName() != "Solar System Observer")	
 		d *= home->getMeanSolarDay();
 
-	setJDay(getJDay() + d);
+	setJD(getJD() + d);
 }
 
 void StelCore::addSiderealDays(double d)
@@ -1258,13 +1270,14 @@
 	const PlanetP& home = position->getHomePlanet();
 	if (home->getEnglishName() != "Solar System Observer")
 		d *= home->getSiderealDay();
-	setJDay(getJDay() + d);
+	setJD(getJD() + d);
 }
 
 // Get the sidereal time shifted by the observer longitude
 double StelCore::getLocalSiderealTime() const
 {
-	return (position->getHomePlanet()->getSiderealTime(JDay)+position->getCurrentLocation().longitude)*M_PI/180.;
+	// On Earth, this requires UT deliberately with all its faults, on other planets we use the more regular TT.
+	return (position->getHomePlanet()->getSiderealTime(getJD(), getJDE())+position->getCurrentLocation().longitude)*M_PI/180.;
 }
 
 //! Get the duration of a sidereal day for the current observer in day.
@@ -1353,16 +1366,19 @@
 	if (getRealTimeSpeed())
 	{
 		// Get rid of the error from the 1 /
-		JDay = JDayOfLastJDayUpdate + (StelApp::getTotalRunTime() - secondsOfLastJDayUpdate) / ONE_OVER_JD_SECOND;
+		// JDay = JDayOfLastJDayUpdate + (StelApp::getTotalRunTime() - secondsOfLastJDayUpdate) / ONE_OVER_JD_SECOND;
+		// GZ I don't understand the comment. Is the constant wrong?
+		JD.first = jdOfLastJDUpdate + (StelApp::getTotalRunTime() - secondsOfLastJDUpdate) * JD_SECOND;
 	}
 	else
 	{
-		JDay = JDayOfLastJDayUpdate + (StelApp::getTotalRunTime() - secondsOfLastJDayUpdate) * timeSpeed;
+		JD.first = jdOfLastJDUpdate + (StelApp::getTotalRunTime() - secondsOfLastJDUpdate) * timeSpeed;
 	}
 
 	// Fix time limits to -100000 to +100000 to prevent bugs
-	if (JDay>38245309.499988) JDay = 38245309.499988;
-	if (JDay<-34803211.500012) JDay = -34803211.500012;
+	if (JD.first>38245309.499988) JD.first = 38245309.499988;
+	if (JD.first<-34803211.500012) JD.first = -34803211.500012;
+	JD.second=computeDeltaT(JD.first);
 
 	if (position->isObserverLifeOver())
 	{
@@ -1380,14 +1396,16 @@
 	position->update(deltaTime);
 
 	// Position of sun and all the satellites (ie planets)
-	SolarSystem* solsystem = (SolarSystem*)StelApp::getInstance().getModuleMgr().getModule("SolarSystem");
-	solsystem->computePositions(getJDay(), position->getHomePlanet()->getHeliocentricEclipticPos());
+	// GZ maybe setting this static can speedup a bit?
+	static SolarSystem* solsystem = (SolarSystem*)StelApp::getInstance().getModuleMgr().getModule("SolarSystem");
+	// Likely the most important location where we need JDE:
+	solsystem->computePositions(getJDE(), position->getHomePlanet()->getHeliocentricEclipticPos());
 }
 
 void StelCore::resetSync()
 {
-	JDayOfLastJDayUpdate = getJDay();
-	secondsOfLastJDayUpdate = StelApp::getTotalRunTime();
+	jdOfLastJDUpdate = getJD();
+	secondsOfLastJDUpdate = StelApp::getTotalRunTime();
 }
 
 void StelCore::setStartupTimeMode(const QString& s)
@@ -1395,7 +1413,15 @@
 	startupTimeMode = s;
 }
 
-double StelCore::getDeltaT(double jDay) const
+// return precomputed DeltaT in seconds. Public.
+double StelCore::getDeltaT() const
+{
+	return JD.second;
+}
+
+
+// compute and return DeltaT in seconds. Try not to call it directly, current DeltaT, JD, and JDE are available.
+double StelCore::computeDeltaT(const double JD) const
 {
 	double DeltaT = 0.;
 	double ndot = 0.;
@@ -1410,149 +1436,156 @@
 		case Schoch:
 			// Schoch (1931) algorithm for DeltaT
 			ndot = -29.68; // n.dot = -29.68"/cy/cy
-			DeltaT = StelUtils::getDeltaTBySchoch(jDay);
+			DeltaT = StelUtils::getDeltaTBySchoch(JD);
 			break;
 		case Clemence:
 			// Clemence (1948) algorithm for DeltaT
 			ndot = -22.44; // n.dot = -22.44 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByClemence(jDay);
+			DeltaT = StelUtils::getDeltaTByClemence(JD);
 			break;
 		case IAU:
 			// IAU (1952) algorithm for DeltaT, based on observations by Spencer Jones (1939)
 			ndot = -22.44; // n.dot = -22.44 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByIAU(jDay);
+			DeltaT = StelUtils::getDeltaTByIAU(JD);
 			break;
 		case AstronomicalEphemeris:
 			// Astronomical Ephemeris (1960) algorithm for DeltaT
 			ndot = -22.44; // n.dot = -22.44 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByAstronomicalEphemeris(jDay);
+			DeltaT = StelUtils::getDeltaTByAstronomicalEphemeris(JD);
 			break;
 		case TuckermanGoldstine:
 			// Tuckerman (1962, 1964) & Goldstine (1973) algorithm for DeltaT
 			//FIXME: n.dot
 			ndot = -22.44; // n.dot = -22.44 "/cy/cy ???
-			DeltaT = StelUtils::getDeltaTByTuckermanGoldstine(jDay);
+			DeltaT = StelUtils::getDeltaTByTuckermanGoldstine(JD);
 			break;
 		case MullerStephenson:
 			// Muller & Stephenson (1975) algorithm for DeltaT
 			ndot = -37.5; // n.dot = -37.5 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByMullerStephenson(jDay);
+			DeltaT = StelUtils::getDeltaTByMullerStephenson(JD);
 			break;
 		case Stephenson1978:
 			// Stephenson (1978) algorithm for DeltaT
 			ndot = -30.0; // n.dot = -30.0 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByStephenson1978(jDay);
+			DeltaT = StelUtils::getDeltaTByStephenson1978(JD);
 			break;
 		case SchmadelZech1979:
 			// Schmadel & Zech (1979) algorithm for DeltaT
 			ndot = -23.8946; // n.dot = -23.8946 "/cy/cy
-			DeltaT = StelUtils::getDeltaTBySchmadelZech1979(jDay);
+			DeltaT = StelUtils::getDeltaTBySchmadelZech1979(JD);
 			break;
 		case MorrisonStephenson1982:
 			// Morrison & Stephenson (1982) algorithm for DeltaT (used by RedShift)
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByMorrisonStephenson1982(jDay);
+			DeltaT = StelUtils::getDeltaTByMorrisonStephenson1982(JD);
 			break;
 		case StephensonMorrison1984:
 			// Stephenson & Morrison (1984) algorithm for DeltaT
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByStephensonMorrison1984(jDay);
+			DeltaT = StelUtils::getDeltaTByStephensonMorrison1984(JD);
 			break;
 		case StephensonHoulden:
 			// Stephenson & Houlden (1986) algorithm for DeltaT
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByStephensonHoulden(jDay);
+			DeltaT = StelUtils::getDeltaTByStephensonHoulden(JD);
 			break;
 		case Espenak:
 			// Espenak (1987, 1989) algorithm for DeltaT
 			//FIXME: n.dot
 			ndot = -23.8946; // n.dot = -23.8946 "/cy/cy ???
-			DeltaT = StelUtils::getDeltaTByEspenak(jDay);
+			DeltaT = StelUtils::getDeltaTByEspenak(JD);
 			break;
 		case Borkowski:
 			// Borkowski (1988) algorithm for DeltaT, relates to ELP2000-85!
 			ndot = -23.895; // GZ: I see -23.895 in the paper, not -23.859; (?) // n.dot = -23.859 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByBorkowski(jDay);
+			DeltaT = StelUtils::getDeltaTByBorkowski(JD);
 			break;
 		case SchmadelZech1988:
 			// Schmadel & Zech (1988) algorithm for DeltaT
 			//FIXME: n.dot
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy ???
-			DeltaT = StelUtils::getDeltaTBySchmadelZech1988(jDay);
+			DeltaT = StelUtils::getDeltaTBySchmadelZech1988(JD);
 			break;
 		case ChaprontTouze:
 			// Chapront-Touzé & Chapront (1991) algorithm for DeltaT
 			ndot = -23.8946; // n.dot = -23.8946 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByChaprontTouze(jDay);
+			DeltaT = StelUtils::getDeltaTByChaprontTouze(JD);
 			break;
 		case StephensonMorrison1995:
 			// Stephenson & Morrison (1995) algorithm for DeltaT
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByStephensonMorrison1995(jDay);
+			DeltaT = StelUtils::getDeltaTByStephensonMorrison1995(JD);
 			break;
 		case Stephenson1997:
 			// Stephenson (1997) algorithm for DeltaT
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByStephenson1997(jDay);
+			DeltaT = StelUtils::getDeltaTByStephenson1997(JD);
 			break;
 		case ChaprontMeeus:
 			// Chapront, Chapront-Touze & Francou (1997) & Meeus (1998) algorithm for DeltaT
 			ndot = -25.7376; // n.dot = -25.7376 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByChaprontMeeus(jDay);
+			DeltaT = StelUtils::getDeltaTByChaprontMeeus(JD);
 			break;
 		case JPLHorizons:
 			// JPL Horizons algorithm for DeltaT
 			ndot = -25.7376; // n.dot = -25.7376 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByJPLHorizons(jDay);
+			DeltaT = StelUtils::getDeltaTByJPLHorizons(JD);
 			break;
 		case MeeusSimons:
 			// Meeus & Simons (2000) algorithm for DeltaT
 			ndot = -25.7376; // n.dot = -25.7376 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByMeeusSimons(jDay);
+			DeltaT = StelUtils::getDeltaTByMeeusSimons(JD);
 			break;
 		case ReingoldDershowitz:
 			// Reingold & Dershowitz (2002, 2007) algorithm for DeltaT
 			// FIXME: n.dot
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy ???
-			DeltaT = StelUtils::getDeltaTByReingoldDershowitz(jDay);
+			DeltaT = StelUtils::getDeltaTByReingoldDershowitz(JD);
 			break;
 		case MontenbruckPfleger:
 			// Montenbruck & Pfleger (2000) algorithm for DeltaT
 			// NOTE: book not contains n.dot value
 			// FIXME: n.dot
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy ???
-			DeltaT = StelUtils::getDeltaTByMontenbruckPfleger(jDay);
+			DeltaT = StelUtils::getDeltaTByMontenbruckPfleger(JD);
 			break;
 		case MorrisonStephenson2004:
 			// Morrison & Stephenson (2004, 2005) algorithm for DeltaT
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByMorrisonStephenson2004(jDay);
+			DeltaT = StelUtils::getDeltaTByMorrisonStephenson2004(JD);
 			break;
 		case Reijs:
 			// Reijs (2006) algorithm for DeltaT
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByReijs(jDay);
+			DeltaT = StelUtils::getDeltaTByReijs(JD);
 			break;
 		case EspenakMeeus:
 			// Espenak & Meeus (2006) algorithm for DeltaT
 			ndot = -25.858; // n.dot = -25.858 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByEspenakMeeus(jDay);
+			DeltaT = StelUtils::getDeltaTByEspenakMeeus(JD);
+			break;
+		case EspenakMeeusZeroMoonAccel:
+			// This is a trying area. Something is wrong with DeltaT, maybe ndot is still not applied correctly.
+			// Espenak & Meeus (2006) algorithm for DeltaT
+			ndot = -25.858; // n.dot = -25.858 "/cy/cy
+			dontUseMoon = true;
+			DeltaT = StelUtils::getDeltaTByEspenakMeeus(JD);
 			break;
 		case Banjevic:
 			// Banjevic (2006) algorithm for DeltaT
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByBanjevic(jDay);
+			DeltaT = StelUtils::getDeltaTByBanjevic(JD);
 			break;
 		case IslamSadiqQureshi:
 			// Islam, Sadiq & Qureshi (2008 + revisited 2013) algorithm for DeltaT (6 polynomials)
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByIslamSadiqQureshi(jDay);
+			DeltaT = StelUtils::getDeltaTByIslamSadiqQureshi(JD);
 			dontUseMoon = true; // Seems this solutions doesn't use value of secular acceleration of the Moon
 			break;
 		case KhalidSultanaZaidi:
 			// M. Khalid, Mariam Sultana and Faheem Zaidi polinomial approximation of time period 1620-2013 (2014)
 			ndot = -26.0; // n.dot = -26.0 "/cy/cy
-			DeltaT = StelUtils::getDeltaTByKhalidSultanaZaidi(jDay);
+			DeltaT = StelUtils::getDeltaTByKhalidSultanaZaidi(JD);
 			dontUseMoon = true; // Seems this solutions doesn't use value of secular acceleration of the Moon
 			break;
 		case Custom:
@@ -1560,14 +1593,14 @@
 			ndot = getDeltaTCustomNDot(); // n.dot = custom value "/cy/cy
 			int year, month, day;
 			Vec3f coeff = getDeltaTCustomEquationCoefficients();
-			StelUtils::getDateFromJulianDay(jDay, &year, &month, &day);			
+			StelUtils::getDateFromJulianDay(JD, &year, &month, &day);
 			double u = (StelUtils::getDecYear(year,month,day)-getDeltaTCustomYear())/100;
 			DeltaT = coeff[0] + u*(coeff[1] + u*coeff[2]);
 			break;
 	}
 
 	if (!dontUseMoon)
-		DeltaT += StelUtils::getMoonSecularAcceleration(jDay, ndot);
+		DeltaT += StelUtils::getMoonSecularAcceleration(JD, ndot);
 
 	return DeltaT;
 }
@@ -1604,91 +1637,94 @@
 			description = q_("Correction is disabled. Use only if you know what you are doing!");
 			break;
 		case Schoch: // historical value.
-			description = q_("This historical formula was obtained by C. Schoch in 1931 and was used by G. Henriksson in his article <em>Einstein's Theory of Relativity Confirmed by Ancient Solar Eclipses</em> (%1). See for more info %2here%3.").arg("2009").arg("<a href='http://journalofcosmology.com/AncientAstronomy123.html'>").arg("</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This historical formula was obtained by C. Schoch in 1931 and was used by G. Henriksson in his article <em>Einstein's Theory of Relativity Confirmed by Ancient Solar Eclipses</em> (%1). See for more info %2here%3.").arg("2009").arg("<a href='http://journalofcosmology.com/AncientAstronomy123.html'>").arg("</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case Clemence: // historical value.
-			description = q_("This empirical equation was published by G. M. Clemence in the article <em>On the system of astronomical constants</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/1948AJ.....53..169C'>1948</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This empirical equation was published by G. M. Clemence in the article <em>On the system of astronomical constants</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/1948AJ.....53..169C'>1948</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case IAU: // historical value.
-			description = q_("This formula is based on a study of post-1650 observations of the Sun, the Moon and the planets by Spencer Jones (%1) and used by Jean Meeus in his <em>Astronomical Formulae for Calculators</em>. It was also adopted in the PC program SunTracker Pro.").arg("<a href='http://adsabs.harvard.edu/abs/1939MNRAS..99..541S'>1939</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This formula is based on a study of post-1650 observations of the Sun, the Moon and the planets by Spencer Jones (%1) and used by Jean Meeus in his <em>Astronomical Formulae for Calculators</em>. It was also adopted in the PC program SunTracker Pro.").arg("<a href='http://adsabs.harvard.edu/abs/1939MNRAS..99..541S'>1939</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			// find year of publication of AFFC
 			break;
 		case AstronomicalEphemeris: // historical value.
-			description = q_("This is a slightly modified version of the IAU (1952) formula which was adopted in the <em>Astronomical Ephemeris</em> and in the <em>Canon of Solar Eclipses</em> by Mucke & Meeus (1983).").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This is a slightly modified version of the IAU (1952) formula which was adopted in the <em>Astronomical Ephemeris</em> and in the <em>Canon of Solar Eclipses</em> by Mucke & Meeus (1983).").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			// TODO: expand the sentence: ... adopted ... from 19xx-19yy?
 			break;
 		case TuckermanGoldstine: // historical value.
-			description = q_("The tables of Tuckerman (1962, 1964) list the positions of the Sun, the Moon and the planets at 5- and 10-day intervals from 601 BCE to 1649 CE. The same relation was also implicitly adopted in the syzygy tables of Goldstine (1973).").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("The tables of Tuckerman (1962, 1964) list the positions of the Sun, the Moon and the planets at 5- and 10-day intervals from 601 BCE to 1649 CE. The same relation was also implicitly adopted in the syzygy tables of Goldstine (1973).").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			// TODO: These tables are sometimes found cited, but I have no details. Maybe add "based on ... " ?
 			break;
 		case MullerStephenson:
-			description = q_("This equation was published by P. M. Muller and F. R. Stephenson in the article <em>The accelerations of the earth and moon from early astronomical observations</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/1975grhe.conf..459M'>1975</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This equation was published by P. M. Muller and F. R. Stephenson in the article <em>The accelerations of the earth and moon from early astronomical observations</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/1975grhe.conf..459M'>1975</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case Stephenson1978:
-			description = q_("This equation was published by F. R. Stephenson in the article <em>Pre-Telescopic Astronomical Observations</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/1978tfer.conf....5S'>1978</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This equation was published by F. R. Stephenson in the article <em>Pre-Telescopic Astronomical Observations</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/1978tfer.conf....5S'>1978</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case SchmadelZech1979: // outdated data fit, historical value?
-			description = q_("This 12th-order polynomial equation (outdated and superseded by Schmadel & Zech (1988)) was published by L. D. Schmadel and G. Zech in the article <em>Polynomial approximations for the correction delta T E.T.-U.T. in the period 1800-1975</em> (%1) as fit through data published by Brouwer (1952).").arg("<a href='http://adsabs.harvard.edu/abs/1979AcA....29..101S'>1979</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This 12th-order polynomial equation (outdated and superseded by Schmadel & Zech (1988)) was published by L. D. Schmadel and G. Zech in the article <em>Polynomial approximations for the correction delta T E.T.-U.T. in the period 1800-1975</em> (%1) as fit through data published by Brouwer (1952).").arg("<a href='http://adsabs.harvard.edu/abs/1979AcA....29..101S'>1979</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case MorrisonStephenson1982:
-			description = q_("This algorithm was adopted in P. Bretagnon & L. Simon's <em>Planetary Programs and Tables from -4000 to +2800</em> (1986) and in the PC planetarium program RedShift.").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This algorithm was adopted in P. Bretagnon & L. Simon's <em>Planetary Programs and Tables from -4000 to +2800</em> (1986) and in the PC planetarium program RedShift.").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case StephensonMorrison1984: // PRIMARY SOURCE
-			description = q_("This formula was published by F. R. Stephenson and L. V. Morrison in the article <em>Long-term changes in the rotation of the earth - 700 B.C. to A.D. 1980</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/1984RSPTA.313...47S'>1984</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This formula was published by F. R. Stephenson and L. V. Morrison in the article <em>Long-term changes in the rotation of the earth - 700 B.C. to A.D. 1980</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/1984RSPTA.313...47S'>1984</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case StephensonHoulden:
-			description = q_("This algorithm is used in the PC planetarium program Guide 7.").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This algorithm is used in the PC planetarium program Guide 7.").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case Espenak: // limited range, but wide availability?
-			description = q_("This algorithm was given by F. Espenak in his <em>Fifty Year Canon of Solar Eclipses: 1986-2035</em> (1987) and in his <em>Fifty Year Canon of Lunar Eclipses: 1986-2035</em> (1989).").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This algorithm was given by F. Espenak in his <em>Fifty Year Canon of Solar Eclipses: 1986-2035</em> (1987) and in his <em>Fifty Year Canon of Lunar Eclipses: 1986-2035</em> (1989).").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case Borkowski: // Linked to ELP2000-85, so it's important...
-			description = q_("This formula was obtained by K.M. Borkowski (%1) from an analysis of 31 solar eclipse records dating between 2137 BCE and 1715 CE.").arg("<a href='http://adsabs.harvard.edu/abs/1988A&A...205L...8B'>1988</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This formula was obtained by K.M. Borkowski (%1) from an analysis of 31 solar eclipse records dating between 2137 BCE and 1715 CE.").arg("<a href='http://adsabs.harvard.edu/abs/1988A&A...205L...8B'>1988</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case SchmadelZech1988: // data fit through Stephenson&Morrison1984, which itself is important. Unclear who uses this version?
-			description = q_("This 12th-order polynomial equation was published by L. D. Schmadel and G. Zech in the article <em>Empirical Transformations from U.T. to E.T. for the Period 1800-1988</em> (%1) as data fit through values given by Stephenson & Morrison (1984).").arg("<a href='http://adsabs.harvard.edu/abs/1988AN....309..219S'>1988</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This 12th-order polynomial equation was published by L. D. Schmadel and G. Zech in the article <em>Empirical Transformations from U.T. to E.T. for the Period 1800-1988</em> (%1) as data fit through values given by Stephenson & Morrison (1984).").arg("<a href='http://adsabs.harvard.edu/abs/1988AN....309..219S'>1988</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case ChaprontTouze:
-			description = q_("This formula was adopted by M. Chapront-Touze & J. Chapront in the shortened version of the ELP 2000-85 lunar theory in their <em>Lunar Tables and Programs from 4000 B.C. to A.D. 8000</em> (1991).").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This formula was adopted by M. Chapront-Touze & J. Chapront in the shortened version of the ELP 2000-85 lunar theory in their <em>Lunar Tables and Programs from 4000 B.C. to A.D. 8000</em> (1991).").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case StephensonMorrison1995:
-			description = q_("This equation was published by F. R. Stephenson and L. V. Morrison in the article <em>Long-Term Fluctuations in the Earth's Rotation: 700 BC to AD 1990</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/1995RSPTA.351..165S'>1995</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This equation was published by F. R. Stephenson and L. V. Morrison in the article <em>Long-Term Fluctuations in the Earth's Rotation: 700 BC to AD 1990</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/1995RSPTA.351..165S'>1995</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case Stephenson1997:
-			description = q_("F. R. Stephenson published this formula in his book <em>Historical Eclipses and Earth's Rotation</em> (%1).").arg("<a href='http://ebooks.cambridge.org/ebook.jsf?bid=CBO9780511525186'>1997</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("F. R. Stephenson published this formula in his book <em>Historical Eclipses and Earth's Rotation</em> (%1).").arg("<a href='http://ebooks.cambridge.org/ebook.jsf?bid=CBO9780511525186'>1997</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case ChaprontMeeus:
-			description = q_("From J. Meeus, <em>Astronomical Algorithms</em> (2nd ed., 1998), and widely used. Table for 1620..2000, and includes a variant of Chapront, Chapront-Touze & Francou (1997) for dates outside 1620..2000.").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("From J. Meeus, <em>Astronomical Algorithms</em> (2nd ed., 1998), and widely used. Table for 1620..2000, and includes a variant of Chapront, Chapront-Touze & Francou (1997) for dates outside 1620..2000.").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case JPLHorizons:
-			description = q_("The JPL Solar System Dynamics Group of the NASA Jet Propulsion Laboratory use this formula in their interactive website %1JPL Horizons%2.").arg("<a href='http://ssd.jpl.nasa.gov/?horizons'>").arg("</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("The JPL Solar System Dynamics Group of the NASA Jet Propulsion Laboratory use this formula in their interactive website %1JPL Horizons%2.").arg("<a href='http://ssd.jpl.nasa.gov/?horizons'>").arg("</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case MeeusSimons:
-			description = q_("This polynome was published by J. Meeus and L. Simons in article <em>Polynomial approximations to Delta T, 1620-2000 AD</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/2000JBAA..110..323M'>2000</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This polynome was published by J. Meeus and L. Simons in article <em>Polynomial approximations to Delta T, 1620-2000 AD</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/2000JBAA..110..323M'>2000</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case MontenbruckPfleger: // uninspired
-			description = q_("The fourth edition of O. Montenbruck & T. Pfleger's <em>Astronomy on the Personal Computer</em> (2000) provides simple 3rd-order polynomial data fits for the recent past.").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("The fourth edition of O. Montenbruck & T. Pfleger's <em>Astronomy on the Personal Computer</em> (2000) provides simple 3rd-order polynomial data fits for the recent past.").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case ReingoldDershowitz: //
-			description = q_("E. M. Reingold & N. Dershowitz present this polynomial data fit in <em>Calendrical Calculations</em> (3rd ed. 2007) and in their <em>Calendrical Tabulations</em> (2002). It is based on Jean Meeus' <em>Astronomical Algorithms</em> (1991).").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("E. M. Reingold & N. Dershowitz present this polynomial data fit in <em>Calendrical Calculations</em> (3rd ed. 2007) and in their <em>Calendrical Tabulations</em> (2002). It is based on Jean Meeus' <em>Astronomical Algorithms</em> (1991).").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case MorrisonStephenson2004: // PRIMARY SOURCE
-			description = q_("This important solution was published by L. V. Morrison and F. R. Stephenson in article <em>Historical values of the Earth's clock error %1T and the calculation of eclipses</em> (%2) with addendum in (%3).").arg(QChar(0x0394)).arg("<a href='http://adsabs.harvard.edu/abs/2004JHA....35..327M'>2004</a>").arg("<a href='http://adsabs.harvard.edu/abs/2005JHA....36..339M'>2005</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This important solution was published by L. V. Morrison and F. R. Stephenson in article <em>Historical values of the Earth's clock error %1T and the calculation of eclipses</em> (%2) with addendum in (%3).").arg(QChar(0x0394)).arg("<a href='http://adsabs.harvard.edu/abs/2004JHA....35..327M'>2004</a>").arg("<a href='http://adsabs.harvard.edu/abs/2005JHA....36..339M'>2005</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case Reijs:
-			description = q_("From the Length of Day (LOD; as determined by Stephenson & Morrison (%2)), Victor Reijs derived a %1T formula by using a Simplex optimisation with a cosine and square function. This is based on a possible periodicy described by Stephenson (%2). See for more info %3here%4.").arg(QChar(0x0394)).arg("<a href='http://adsabs.harvard.edu/abs/2004JHA....35..327M'>2004</a>").arg("<a href='http://www.iol.ie/~geniet/eng/DeltaTeval.htm'>").arg("</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("From the Length of Day (LOD; as determined by Stephenson & Morrison (%2)), Victor Reijs derived a %1T formula by using a Simplex optimisation with a cosine and square function. This is based on a possible periodicy described by Stephenson (%2). See for more info %3here%4.").arg(QChar(0x0394)).arg("<a href='http://adsabs.harvard.edu/abs/2004JHA....35..327M'>2004</a>").arg("<a href='http://www.iol.ie/~geniet/eng/DeltaTeval.htm'>").arg("</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case EspenakMeeus: // GENERAL SOLUTION
-			description = q_("This solution by F. Espenak and J. Meeus, based on Morrison & Stephenson (2004) and a polynomial fit through tabulated values for 1600-2000, is used for the %1NASA Eclipse Web Site%2 and in their <em>Five Millennium Canon of Solar Eclipses: -1900 to +3000</em> (2006). This formula is also used in the solar, lunar and planetary ephemeris program SOLEX.").arg("<a href='http://eclipse.gsfc.nasa.gov/eclipse.html'>").arg("</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker)).append(" <em>").append(q_("Used by default.")).append("</em>");
+			description = q_("This solution by F. Espenak and J. Meeus, based on Morrison & Stephenson (2004) and a polynomial fit through tabulated values for 1600-2000, is used for the %1NASA Eclipse Web Site%2 and in their <em>Five Millennium Canon of Solar Eclipses: -1900 to +3000</em> (2006). This formula is also used in the solar, lunar and planetary ephemeris program SOLEX.").arg("<a href='http://eclipse.gsfc.nasa.gov/eclipse.html'>").arg("</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker)).append(" <em>").append(q_("Used by default.")).append("</em>");
+			break;
+		case EspenakMeeusZeroMoonAccel: // PATCHED SOLUTION
+			description = q_("PATCHED VERSION WITHOUT ADDITIONAL LUNAR ACCELERATION. This solution by F. Espenak and J. Meeus, based on Morrison & Stephenson (2004) and a polynomial fit through tabulated values for 1600-2000, is used for the %1NASA Eclipse Web Site%2 and in their <em>Five Millennium Canon of Solar Eclipses: -1900 to +3000</em> (2006). This formula is also used in the solar, lunar and planetary ephemeris program SOLEX.").arg("<a href='http://eclipse.gsfc.nasa.gov/eclipse.html'>").arg("</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker)).append(" <em>").append("</em>");
 			break;
 		case Banjevic:
-			description = q_("This solution by B. Banjevic, based on Stephenson & Morrison (1984), was published in article <em>Ancient eclipses and dating the fall of Babylon</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/2006POBeo..80..251B'>2006</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This solution by B. Banjevic, based on Stephenson & Morrison (1984), was published in article <em>Ancient eclipses and dating the fall of Babylon</em> (%1).").arg("<a href='http://adsabs.harvard.edu/abs/2006POBeo..80..251B'>2006</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case IslamSadiqQureshi:
-			description = q_("This solution by S. Islam, M. Sadiq and M. S. Qureshi, based on Meeus & Simons (2000), was published in article <em>Error Minimization of Polynomial Approximation of DeltaT</em> (%1) and revisited by Sana Islam in 2013.").arg("<a href='http://www.ias.ac.in/jaa/dec2008/JAA610.pdf'>2008</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This solution by S. Islam, M. Sadiq and M. S. Qureshi, based on Meeus & Simons (2000), was published in article <em>Error Minimization of Polynomial Approximation of DeltaT</em> (%1) and revisited by Sana Islam in 2013.").arg("<a href='http://www.ias.ac.in/jaa/dec2008/JAA610.pdf'>2008</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case KhalidSultanaZaidi:
-			description = q_("This polynomial approximation with 0.6 seconds of accuracy by M. Khalid, Mariam Sultana and Faheem Zaidi was published in <em>Delta T: Polynomial Approximation of Time Period 1620-2013</em> (%1).").arg("<a href='http://dx.doi.org/10.1155/2014/480964'>2014</a>").append(getCurrentDeltaTAlgorithmValidRange(jd, &marker));
+			description = q_("This polynomial approximation with 0.6 seconds of accuracy by M. Khalid, Mariam Sultana and Faheem Zaidi was published in <em>Delta T: Polynomial Approximation of Time Period 1620-2013</em> (%1).").arg("<a href='http://dx.doi.org/10.1155/2014/480964'>2014</a>").append(getCurrentDeltaTAlgorithmValidRangeDescription(jd, &marker));
 			break;
 		case Custom:
 			description = q_("This is a quadratic formula for calculation of %1T with coefficients defined by the user.").arg(QChar(0x0394));
@@ -1699,7 +1735,7 @@
 	return description;
 }
 
-QString StelCore::getCurrentDeltaTAlgorithmValidRange(double jDay, QString *marker) const
+QString StelCore::getCurrentDeltaTAlgorithmValidRangeDescription(const double JD, QString *marker) const
 {
 	QString validRange = "";
 	QString validRangeAppendix = "";
@@ -1707,7 +1743,7 @@
 	int year, month, day;
 	int start = 0;
 	int finish = 0;
-	StelUtils::getDateFromJulianDay(jDay, &year, &month, &day);
+	StelUtils::getDateFromJulianDay(JD, &year, &month, &day);
 	switch (getCurrentDeltaTAlgorithm())
 	{
 		case WithoutCorrection:
@@ -1818,6 +1854,7 @@
 			finish	= 1100; // not 1620; // GZ: Not applicable for telescopic era, and better not after 1100 (pers.comm.)
 			break;
 		case EspenakMeeus: // the default, range stated in the Canon, p. 14.
+		case EspenakMeeusZeroMoonAccel:
 			start	= -1999;
 			finish	= 3000;
 			break;
@@ -1847,7 +1884,7 @@
 			validRange = q_("Valid range of usage: between years %1 and %2, %3.").arg(start).arg(finish).arg(validRangeAppendix);
 		else
 			validRange = q_("Valid range of usage: between years %1 and %2.").arg(start).arg(finish);
-		if (start > year || year > finish)
+		if ((year < start) || (finish < year))
 			*marker = "*";
 	}
 	else
@@ -1857,8 +1894,7 @@
 }
 
 // return if sky plus atmosphere is bright enough from sunlight so that e.g. screen labels should be rendered dark.
-// Could be renamed to isBrightDaylight()
-bool StelCore::isDay() const
+bool StelCore::isBrightDaylight() const
 {
 	const Vec3d& sunPos = GETSTELMODULE(SolarSystem)->getSun()->getAltAzPosGeometric(this);
 	return sunPos[2] > -0.12; // Nautical twilight (0.12 > sin (6 deg),
@@ -1866,5 +1902,5 @@
 
 double StelCore::getCurrentEpoch() const
 {
-	return 2000.0 + (getJDay() - 2451545.0)/365.25;
+	return 2000.0 + (getJD() - 2451545.0)/365.25;
 }

=== modified file 'src/core/StelCore.hpp'
--- src/core/StelCore.hpp	2015-08-02 17:12:29 +0000
+++ src/core/StelCore.hpp	2015-08-03 13:17:13 +0000
@@ -28,6 +28,7 @@
 #include <QString>
 #include <QStringList>
 #include <QTime>
+#include <QPair>
 
 class StelToneReproducer;
 class StelSkyDrawer;
@@ -124,6 +125,7 @@
 		MorrisonStephenson2004,         //!< Morrison & Stephenson (2004, 2005) algorithm for DeltaT
 		Reijs,                          //!< Reijs (2006) algorithm for DeltaT
 		EspenakMeeus,                   //!< Espenak & Meeus (2006) algorithm for DeltaT (Recommended, default)
+		EspenakMeeusZeroMoonAccel,      //   Espenak & Meeus (2006) algorithm for DeltaT (but without additional Lunar acceleration. FOR TESTING ONLY, NONPUBLIC)
 		Banjevic,			//!< Banjevic (2006) algorithm for DeltaT
 		IslamSadiqQureshi,		//!< Islam, Sadiq & Qureshi (2008 + revisited 2013) algorithm for DeltaT (6 polynomials)
 		KhalidSultanaZaidi,		//!< M. Khalid, Mariam Sultana and Faheem Zaidi polinomial approximation of time period 1620-2013 (2014)
@@ -269,7 +271,7 @@
 	//! This is used only if the destination planet is different from the starting one.
 	void moveObserverTo(const StelLocation& target, double duration=1., double durationIfPlanetChange=1.);
 
-	// Conversion in standar Julian time format
+	// Conversion in standard Julian time format
 	static const double JD_SECOND;
 	static const double JD_MINUTE;
 	static const double JD_HOUR;
@@ -286,26 +288,21 @@
 	//! Get the duration of a sidereal year for the current observer in days.
 	double getLocalSiderealYearLength() const;
 
-	//! Return the startup mode, can be preset|Preset or anything else
+	//! Return the startup mode, can be "actual" (i.e. take current time from system),
+	//! "today" (take some time e.g. on the evening of today) or "preset" (completely preconfigured).
 	QString getStartupTimeMode();
 	void setStartupTimeMode(const QString& s);
 
-	//! Get Delta-T estimation for a given date.
-	//! @param jDay the date and time expressed as a julian day
-	//! @return Delta-T in seconds
-	//! @note Thanks to Rob van Gent which create a collection from many formulas for calculation of Delta-T: http://www.staff.science.uu.nl/~gent0113/deltat/deltat.htm
-	double getDeltaT(double jDay) const;
-
 	//! Get info about valid range for current algorithm for calculation of Delta-T
-	//! @param jDay the JD
-	//! @param marker the marker for valid range
-	//! @return valid range
-	QString getCurrentDeltaTAlgorithmValidRange(double jDay, QString* marker) const;
+	//! @param JD the Julian Day number to test.
+	//! @param marker receives a string: "*" if jDay is outside valid range, or "?" if range unknown, else an empty string.
+	//! @return valid range as explanatory string.
+	QString getCurrentDeltaTAlgorithmValidRangeDescription(const double JD, QString* marker) const;
 
 	//! Checks for altitude of sun - is it night or day?
 	//! @return true if sun higher than about -6 degrees, i.e. "day" includes civil twilight.
 	//! @note Useful mostly for brightness-controlled GUI decisions like font colors.
-	bool isDay() const;
+	bool isBrightDaylight() const;
 
 	//! Get value of the current Julian epoch (i.e. current year with decimal fraction, e.g. 2012.34567)
 	double getCurrentEpoch() const;
@@ -367,16 +364,43 @@
 	//! Return to the default location and set default landscape with atmosphere and fog effects
 	void returnToHome();
 
-	//! Set the current date in Julian Day
-	void setJDay(double JD);
-	//! Get the current date in Julian Day
-	double getJDay() const;
+	//! Set the current date in Julian Day (UT)
+	void setJD(double newJD);
+	//! Set the current date in Julian Day (TT).
+	//! The name is derived from the classical name "Ephemeris Time", of which TT is the successor.
+	//! It is still frequently used in the literature.
+	void setJDE(double newJDE);
+	//! Get the current date in Julian Day (UT).
+	double getJD() const;
+	//! Get the current date in Julian Day (TT).
+	//! The name is derived from the classical name "Ephemeris Time", of which TT is the successor.
+	//! It is still frequently used in the literature.
+	double getJDE() const;
 
-	//! Set the current date in Modified Julian Day
+	//! Set the current date in Modified Julian Day (UT).
+	//! MJD is simply JD-2400000.5, getting rid of large numbers and starting days at midnight.
+	//! It is mostly used in satellite contexts.
 	void setMJDay(double MJD);
-	//! Get the current date in Modified Julian Day
+	//! Get the current date in Modified Julian Day (UT)
 	double getMJDay() const;
 
+	//! Compute Delta-T estimation for a given date.
+	//! DeltaT is the accumulated effect of earth's rotation slowly getting slower, mostly caused by tidal braking by the Moon.
+	//! For accurate positioning of objects in the sky, we must compute earth-based clock-dependent things like earth rotation, hour angles etc.
+	//! using plain UT, but all orbital motions or rotation of the other planets must be computed in TT, which is a regular time frame.
+	//! Also satellites are computed in the UT frame because (1) they are short-lived and (2) must follow paths over earth ground.
+	//! (Note that we make no further difference between TT and DT, those are regarded equivalent for our purpose.)
+	//!
+	//! @param JD the date and time expressed as a Julian Day
+	//! @return DeltaT in seconds
+	//! @note Thanks to Rob van Gent which create a collection from many formulas for calculation of Delta-T: http://www.staff.science.uu.nl/~gent0113/deltat/deltat.htm
+	//! @note Use this only if needed, prefer calling getDeltaT() for access to the current value.
+	double computeDeltaT(const double JD) const;
+	//! Get current DeltaT.
+	double getDeltaT() const;
+
+
+
 	//! Return the preset sky time in JD
 	double getPresetSkyTime() const;
 	//! Set the preset sky time from a JD
@@ -415,9 +439,9 @@
 	//! get the initial "today time" from the config file
 	QTime getInitTodayTime(void);
 	//! set the initial "today time" from the config file
-	void setInitTodayTime(const QTime& t);
+	void setInitTodayTime(const QTime& time);
 	//! Set the preset sky time from a QDateTime
-	void setPresetSkyTime(QDateTime dt);
+	void setPresetSkyTime(QDateTime dateTime);
 
 	//! Add one [Earth, solar] hour to the current simulation time.
 	void addHour();
@@ -529,7 +553,7 @@
 	//! the selected object is of the correct type - i.e. a planet.
 	void moveObserverToSelected();
 
-	//! Set year for custom equation for calculation of Delta-T
+	//! Set central year for custom equation for calculation of Delta-T
 	//! @param y the year, e.g. 1820
 	void setDeltaTCustomYear(float y) { deltaTCustomYear=y; }
 	//! Set n-dot for custom equation for calculation of Delta-T
@@ -539,7 +563,7 @@
 	//! @param y the coefficients, e.g. -20,0,32
 	void setDeltaTCustomEquationCoefficients(Vec3f c) { deltaTCustomEquationCoeff=c; }
 
-	//! Get year for custom equation for calculation of Delta-T
+	//! Get central year for custom equation for calculation of Delta-T
 	float getDeltaTCustomYear() const { return deltaTCustomYear; }
 	//! Get n-dot for custom equation for calculation of Delta-T
 	float getDeltaTCustomNDot() const { return deltaTCustomNDot; }
@@ -573,6 +597,8 @@
 	void updateTime(double deltaTime);
 	void resetSync();
 
+
+
 	// Matrices used for every coordinate transfo
 	Mat4d matHeliocentricEclipticJ2000ToAltAz; // Transform from heliocentric ecliptic Cartesian (VSOP87A) to topocentric (StelObserver) altazimuthal coordinate
 	Mat4d matAltAzToHeliocentricEclipticJ2000; // Transform from topocentric (StelObserver) altazimuthal coordinate to heliocentric ecliptic Cartesian (VSOP87A)
@@ -597,12 +623,14 @@
 
 	// Time variables
 	double timeSpeed;                  // Positive : forward, Negative : Backward, 1 = 1sec/sec
-	double JDay;                       // Curent time in Julian day
+	//double JDay;                     // Current time in Julian day. IN V0.12 TO V0.14, this was JD in TT, and all places where UT was required had to subtract getDeltaT() explicitly.
+	QPair<double,double> JD;           // From 0.14 on: JD.first=JD_UT, JD.second=DeltaT=TT-UT. To gain JD_TT, compute JDE=JD.first+JD.second or just call getJDE()
+					   // Use is best with calls getJD()/setJD() and getJDE()/setJDE() to explicitly state which flavour of JD you need.
 	double presetSkyTime;
 	QTime initTodayTime;
 	QString startupTimeMode;
-	double secondsOfLastJDayUpdate;         // Time in seconds when the time rate or time last changed
-	double JDayOfLastJDayUpdate;         // JDay when the time rate or time last changed
+	double secondsOfLastJDUpdate;    // Time in seconds when the time rate or time last changed
+	double jdOfLastJDUpdate;         // JD when the time rate or time last changed
 
 	// Variables for custom equation of Delta-T
 	Vec3f deltaTCustomEquationCoeff;

=== modified file 'src/core/StelMovementMgr.cpp'
--- src/core/StelMovementMgr.cpp	2015-07-24 14:56:52 +0000
+++ src/core/StelMovementMgr.cpp	2015-08-03 13:17:13 +0000
@@ -321,7 +321,7 @@
 {
 	DragHistoryEntry e;
 	e.runTime=StelApp::getInstance().getTotalRunTime();
-	e.jd=core->getJDay();
+	e.jd=core->getJD();
 	e.x=x;
 	e.y=y;
 	timeDragHistory.append(e);
@@ -907,7 +907,7 @@
 	viewDirectionMountFrame = j2000ToMountFrame(v);
 }
 
-void StelMovementMgr::panView(double deltaAz, double deltaAlt)
+void StelMovementMgr::panView(const double deltaAz, const double deltaAlt)
 {
 	double azVision, altVision;
 	StelUtils::rectToSphe(&azVision,&altVision,j2000ToMountFrame(viewDirectionJ2000));
@@ -947,7 +947,7 @@
 		v2[2]=0; v2.normalize();
 		double angle = (v2^v1)[2];
 		double deltaDay = angle/(2.*M_PI)*core->getLocalSiderealDayLength();
-		core->setJDay(core->getJDay()+deltaDay);
+		core->setJD(core->getJD()+deltaDay);
 		addTimeDragPoint(x2, y2);
 	}
 	else

=== modified file 'src/core/StelMovementMgr.hpp'
--- src/core/StelMovementMgr.hpp	2015-07-24 14:56:52 +0000
+++ src/core/StelMovementMgr.hpp	2015-08-03 13:17:13 +0000
@@ -117,7 +117,7 @@
 	//! Changes to viewing direction are instantaneous.
 	//! @param deltaAz change in azimuth angle in radians
 	//! @param deltaAlt change in altitude angle in radians
-	void panView(double deltaAz, double deltaAlt);
+	void panView(const double deltaAz, const double deltaAlt);
 
 	//! Set automove duration in seconds
 	//! @param f the number of seconds it takes for an auto-move operation to complete.

=== modified file 'src/core/StelObject.cpp'
--- src/core/StelObject.cpp	2015-07-28 13:22:40 +0000
+++ src/core/StelObject.cpp	2015-08-03 13:17:13 +0000
@@ -42,21 +42,15 @@
 // Get observer local sidereal coordinate
 Vec3d StelObject::getSiderealPosGeometric(const StelCore* core) const
 {
-	// Hour Angle corrected to Delta-T value
-	// TODO: make code readable by calling siderealTime(JD_UT), this should not contain a deltaT in its algorithm.
-	double dt = (core->getDeltaT(core->getJDay())/240.)*M_PI/180.;
-	return Mat4d::zrotation(-core->getLocalSiderealTime()+dt)* getEquinoxEquatorialPos(core);
+	return Mat4d::zrotation(-core->getLocalSiderealTime())* getEquinoxEquatorialPos(core);
 }
 
 // Get observer local sidereal coordinates, deflected by refraction
 Vec3d StelObject::getSiderealPosApparent(const StelCore* core) const
 {
-	Vec3d v=getAltAzPosApparent(core);
+	Vec3d v=getAltAzPosApparent(core); // These already come with refraction!
 	v = core->altAzToEquinoxEqu(v, StelCore::RefractionOff);
-	// Hour Angle corrected to Delta-T value
-	// TODO: make code readable by calling siderealTime(JD_UT), this should not contain a deltaT in its algorithm.
-	double dt = (core->getDeltaT(core->getJDay())/240.)*M_PI/180.;
-	return Mat4d::zrotation(-core->getLocalSiderealTime()+dt)*v;
+	return Mat4d::zrotation(-core->getLocalSiderealTime())*v;
 }
 
 Vec3d StelObject::getAltAzPosGeometric(const StelCore* core) const
@@ -204,9 +198,8 @@
 		// and because the ecliptical grid of J2000 is also shown for observers on other planets.
 		// The formulation here has never computed the true position of any observer planet's orbital plane except for Earth,
 		// or ever displayed the coordinates in the observer planet's equivalent to Earth's ecliptical coordinates.
-		// As quick test you can observe if in any "Ecliptic coordinate" as seen from e.g. Mars or Jupiter the Sun was ever close to beta=0.
+		// As quick test you can observe if in any "Ecliptic coordinate" as seen from e.g. Mars or Jupiter the Sun was ever close to beta=0 (except if crossing the node...).
 
-		//double ecl = core->getCurrentPlanet()->getRotObliquity(2451545.0);
 		double ecl=GETSTELMODULE(SolarSystem)->getEarth()->getRotObliquity(2451545.0);
 		double ra_equ, dec_equ, lambda, beta;
 		StelUtils::rectToSphe(&ra_equ,&dec_equ,getJ2000EquatorialPos(core));
@@ -267,7 +260,7 @@
 	{
 		Vec3f color = getInfoColor();
 		StelCore* core = StelApp::getInstance().getCore();
-		if (core->isDay() && core->getSkyDrawer()->getFlagHasAtmosphere()==true)
+		if (core->isBrightDaylight() && core->getSkyDrawer()->getFlagHasAtmosphere()==true)
 		{
 			// make info text more readable when atmosphere enabled at daylight.
 			color = StelUtils::strToVec3f(StelApp::getInstance().getSettings()->value("color/daylight_text_color", "0.0,0.0,0.0").toString());

=== modified file 'src/core/StelObserver.cpp'
--- src/core/StelObserver.cpp	2015-07-27 21:55:05 +0000
+++ src/core/StelObserver.cpp	2015-08-03 13:17:13 +0000
@@ -77,9 +77,9 @@
 
 	// rotation:
 	const RotationElements &r(dest->getRotationElements());
-	lastJD = StelApp::getInstance().getCore()->getJDay();
+	lastJDE = StelApp::getInstance().getCore()->getJDE();
 
-	re.offset = r.offset + fmod(re.offset - r.offset + 360.0*( (lastJD-re.epoch)/re.period - (lastJD-r.epoch)/r.period), 360.0);
+	re.offset = r.offset + fmod(re.offset - r.offset + 360.0*( (lastJDE-re.epoch)/re.period - (lastJDE-r.epoch)/r.period), 360.0);
 
 	re.epoch = r.epoch;
 	re.period = r.period;
@@ -218,25 +218,19 @@
 	return rho*a;
 }
 
-Mat4d StelObserver::getRotAltAzToEquatorial(double jd) const
+// For Earth we require JD, for other planets JDE to describe rotation!
+Mat4d StelObserver::getRotAltAzToEquatorial(double JD, double JDE) const
 {
 	double lat = currentLocation.latitude;
 	// TODO: Figure out how to keep continuity in sky as we reach poles
 	// otherwise sky jumps in rotation when reach poles in equatorial mode
 	// This is a kludge
-	// GZ: Actually, why would that be? Lat should be clamped elsewhere. Added tests.
+	// GZ: Actually, why would that be? Lat should be clamped elsewhere. Added tests to track down problems in other locations.
 	Q_ASSERT(lat <=  90.0);
 	Q_ASSERT(lat >= -90.0);
 	if( lat > 90.0 )  lat = 90.0;
 	if( lat < -90.0 ) lat = -90.0;
-	// Include a DeltaT correction. Sidereal time and longitude here are both in degrees, but DeltaT in seconds of time.
-	// 360 degrees = 24hrs; 15 degrees = 1hr = 3600s; 1 degree = 240s
-	// Apply DeltaT correction only for Earth
-	// TODO: make code readable by calling siderealTime(JD_UT), this should not contain a deltaT in its algorithm.
-	double deltaT = 0.;
-	if (getHomePlanet()->getEnglishName()=="Earth")
-		deltaT = StelApp::getInstance().getCore()->getDeltaT(jd)/240.;
-	return Mat4d::zrotation((getHomePlanet()->getSiderealTime(jd)+currentLocation.longitude-deltaT)*M_PI/180.)
+	return Mat4d::zrotation((getHomePlanet()->getSiderealTime(JD, JDE)+currentLocation.longitude)*M_PI/180.)
 		* Mat4d::yrotation((90.-lat)*M_PI/180.);
 }
 

=== modified file 'src/core/StelObserver.hpp'
--- src/core/StelObserver.hpp	2014-02-18 06:36:58 +0000
+++ src/core/StelObserver.hpp	2015-08-03 13:17:13 +0000
@@ -50,7 +50,10 @@
 	Vec3d getCenterVsop87Pos(void) const;
 	//! Get the distance between observer and home planet center in AU
 	double getDistanceFromCenter(void) const;
-	Mat4d getRotAltAzToEquatorial(double jd) const;
+
+	//! returns rotation matrix for conversion of alt-azimuthal to equatorial coordinates
+	//! For Earth we need JD(UT), for other planets JDE! To be general, just have both in here!
+	Mat4d getRotAltAzToEquatorial(double JD, double JDE) const;
 	Mat4d getRotEquatorialToVsop87(void) const;
 
 	virtual const QSharedPointer<Planet> getHomePlanet(void) const;

=== modified file 'src/core/StelUtils.hpp'
--- src/core/StelUtils.hpp	2015-05-10 08:29:58 +0000
+++ src/core/StelUtils.hpp	2015-08-03 13:17:13 +0000
@@ -326,7 +326,7 @@
 		return Vec3f(max, 0, 0);
 	}
 
-	//! Calculate and getting sidereal period in days from semi-major axis (in AU)
+	//! Calculate and return sidereal period in days from semi-major axis (in AU)
 	double calculateSiderealPeriod(const double SemiMajorAxis);
 
 	//! Convert decimal hours to hours, minutes, seconds

=== modified file 'src/core/TrailGroup.cpp'
--- src/core/TrailGroup.cpp	2015-05-12 07:00:45 +0000
+++ src/core/TrailGroup.cpp	2015-08-03 13:17:13 +0000
@@ -36,7 +36,7 @@
 {
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	float currentTime = core->getJDay();
+	float currentTime = core->getJDE();
 	StelProjector::ModelViewTranformP transfo = core->getJ2000ModelViewTransform();
 	transfo->combine(j2000ToTrailNativeInverted);
 	sPainter->setProjector(core->getProjection(transfo));
@@ -66,12 +66,12 @@
 // Add 1 point to all the curves at current time and suppress too old points
 void TrailGroup::update()
 {
-	times.append(StelApp::getInstance().getCore()->getJDay());
+	times.append(StelApp::getInstance().getCore()->getJDE());
 	for (QList<Trail>::Iterator iter=allTrails.begin();iter!=allTrails.end();++iter)
 	{
 		iter->posHistory.append(j2000ToTrailNative*iter->stelObject->getJ2000EquatorialPos(StelApp::getInstance().getCore()));
 	}
-	if (StelApp::getInstance().getCore()->getJDay()-times.at(0)>timeExtent)
+	if (StelApp::getInstance().getCore()->getJDE()-times.at(0)>timeExtent)
 	{
 		times.pop_front();
 		for (QList<Trail>::Iterator iter=allTrails.begin();iter!=allTrails.end();++iter)

=== modified file 'src/core/modules/Atmosphere.cpp'
--- src/core/modules/Atmosphere.cpp	2015-02-01 20:44:54 +0000
+++ src/core/modules/Atmosphere.cpp	2015-08-03 13:17:13 +0000
@@ -220,7 +220,7 @@
 	}
 	else
 		eclipseFactor = 1.f;
-
+	// TODO: compute eclipse factor also for Lunar eclipses! (lp:#1471546)
 
 	// No need to calculate if not visible
 	if (!fader.getInterstate())

=== modified file 'src/core/modules/Comet.cpp'
--- src/core/modules/Comet.cpp	2015-03-15 15:47:35 +0000
+++ src/core/modules/Comet.cpp	2015-08-03 13:17:13 +0000
@@ -89,10 +89,10 @@
 	  dustTailBrightnessFactor(dustTailBrightnessFact)
 {
 	texMapName = atexMapName;
-	lastOrbitJD =0;
-	deltaJD = StelCore::JD_SECOND;
-	deltaJDtail=15.0*StelCore::JD_MINUTE; // update tail geometry every 15 minutes only
-	lastJDtail=0.0;
+	lastOrbitJDE =0;
+	deltaJDE = StelCore::JD_SECOND;
+	deltaJDEtail=15.0*StelCore::JD_MINUTE; // update tail geometry every 15 minutes only
+	lastJDEtail=0.0;
 	orbitCached = 0;
 	closeOrbit = acloseOrbit;
 
@@ -314,27 +314,27 @@
 {
 	Planet::update(deltaTime);
 
-	// The rest used to be in computePosition(), but is better in update(). Unfortunately we need date (JD).
+	// The rest deals with updating tail geometries and brightness
 	StelCore* core=StelApp::getInstance().getCore();
-	double date=core->getJDay();
+	double dateJDE=core->getJDE();
 
 	// The CometOrbit is in fact available in userDataPtr!
 	CometOrbit* orbit=(CometOrbit*)userDataPtr;
 	Q_ASSERT(orbit);
-	if (!orbit->objectDateValid(core->getJDay())) return; // don't do anything if out of useful date range. This allows having hundreds of comet elements.
+	if (!orbit->objectDateValid(dateJDE)) return; // don't do anything if out of useful date range. This allows having hundreds of comet elements.
 
 
 	//GZ: I think we can make deltaJDtail adaptive, depending on distance to sun! For some reason though, this leads to a crash!
 	//deltaJDtail=StelCore::JD_SECOND * qMax(1.0, qMin(eclipticPos.length(), 20.0));
 
-	if (fabs(lastJDtail-date)>deltaJDtail)
+	if (fabs(lastJDEtail-dateJDE)>deltaJDEtail)
 	{
-		lastJDtail=date;
+		lastJDEtail=dateJDE;
 
 		// The CometOrbit is in fact available in userDataPtr!
 		CometOrbit* orbit=(CometOrbit*)userDataPtr;
 		Q_ASSERT(orbit);
-		if (!orbit->objectDateValid(date)) return; // out of useful date range. This should allow having hundreds of comet elements.
+		if (!orbit->objectDateValid(dateJDE)) return; // out of useful date range. This should allow having hundreds of comet elements.
 
 		if (orbit->getUpdateTails()){
 			// Compute lengths and orientations from orbit object, but only if required.
@@ -457,7 +457,7 @@
 		gastailColorArr.fill(gasColor,   gastailVertexArr.length());
 		dusttailColorArr.fill(dustColor, dusttailVertexArr.length());
 	}
-	//qDebug() << "Comet " << getEnglishName() <<  "JD: " << date << "gasR" << gasColor[0] << " dustR" << dustColor[0];
+	//qDebug() << "Comet " << getEnglishName() <<  "JDE: " << date << "gasR" << gasColor[0] << " dustR" << dustColor[0];
 }
 
 
@@ -483,7 +483,7 @@
 	// The CometOrbit is in fact available in userDataPtr!
 	CometOrbit* orbit=(CometOrbit*)userDataPtr;
 	Q_ASSERT(orbit);
-	if (!orbit->objectDateValid(core->getJDay())) return; // don't draw at all if out of useful date range. This allows having hundreds of comet elements.
+	if (!orbit->objectDateValid(core->getJDE())) return; // don't draw at all if out of useful date range. This allows having hundreds of comet elements.
 
 	Mat4d mat = Mat4d::translation(eclipticPos) * rotLocalToParent;
 	// This removed totally the Planet shaking bug!!!

=== modified file 'src/core/modules/Comet.hpp'
--- src/core/modules/Comet.hpp	2014-11-25 13:02:40 +0000
+++ src/core/modules/Comet.hpp	2015-08-03 13:17:13 +0000
@@ -96,14 +96,10 @@
 	//! get sidereal period for comet, days, or returns 0 if not possible (paraboloid, hyperboloid orbit)
 	virtual double getSiderealPeriod() const;
 
-	//! GZ: override from Planet: extend with tail details.
-	//virtual void computePosition(const double date);
-
 	//! re-implementation of Planet's draw()
 	virtual void draw(StelCore* core, float maxMagLabels, const QFont& planetNameFont);
 
 	// re-implementation of Planet's update() to prepare tails (extinction etc). @param deltaTime: ms (since last call)
-	// TODO: computePosition can be removed and things added here!
 	virtual void update(int deltaTime);
 
 private:
@@ -139,8 +135,8 @@
 	Vec2f tailFactors; // result of latest call to getComaDiameterAndTailLengthAU(); Results cached here for infostring. [0]=Coma diameter, [1] gas tail length.
 	bool tailActive;		//! true if there is a tail long enough to be worth drawing. Drawing tails is quite costly.
 	bool tailBright;		//! true if tail is bright enough to draw.
-	double deltaJDtail;             //! like deltaJD, but time difference between tail geometry updates.
-	double lastJDtail;              //! like lastJD, but time of last tail geometry update.
+	double deltaJDEtail;            //! like deltaJDE, but time difference between tail geometry updates.
+	double lastJDEtail;             //! like lastJDE, but time of last tail geometry update.
 	Mat4d gasTailRot;		//! rotation matrix for gas tail parabola
 	Mat4d dustTailRot;		//! rotation matrix for the skewed dust tail parabola
 	float dustTailWidthFactor;      //!< empirical individual broadening of the dust tail end, compared to the gas tail end. Actually, dust tail width=2*comaWidth*dustTailWidthFactor. Default 1.5

=== modified file 'src/core/modules/Constellation.cpp'
--- src/core/modules/Constellation.cpp	2015-07-27 14:57:16 +0000
+++ src/core/modules/Constellation.cpp	2015-08-03 13:17:13 +0000
@@ -260,7 +260,7 @@
 	bool visible = false;
 	int year, month, day;
 	// Get the current month
-	StelUtils::getDateFromJulianDay(StelApp::getInstance().getCore()->getJDay(), &year, &month, &day);
+	StelUtils::getDateFromJulianDay(StelApp::getInstance().getCore()->getJD(), &year, &month, &day);
 	if (endSeason >= beginSeason)
 	{
 		// OK, it's a "normal" season rule...

=== modified file 'src/core/modules/LandscapeMgr.cpp'
--- src/core/modules/LandscapeMgr.cpp	2015-07-13 13:42:56 +0000
+++ src/core/modules/LandscapeMgr.cpp	2015-08-03 13:17:13 +0000
@@ -233,7 +233,8 @@
 	Vec3d sunPos = ssystem->getSun()->getAltAzPosApparent(core);
 	// Compute the moon position in local coordinate
 	Vec3d moonPos = ssystem->getMoon()->getAltAzPosApparent(core);
-	atmosphere->computeColor(core->getJDay(), sunPos, moonPos,
+	// GZ: First parameter in next call is used for particularly earth-bound computations in Schaefer's sky brightness model. Difference DeltaT makes no difference here.
+	atmosphere->computeColor(core->getJDE(), sunPos, moonPos,
 		ssystem->getMoon()->getPhaseAngle(ssystem->getEarth()->getHeliocentricEclipticPos()),
 		core, core->getCurrentLocation().latitude, core->getCurrentLocation().altitude,
 		15.f, 40.f);	// Temperature = 15c, relative humidity = 40%

=== modified file 'src/core/modules/MinorPlanet.cpp'
--- src/core/modules/MinorPlanet.cpp	2015-01-30 17:31:11 +0000
+++ src/core/modules/MinorPlanet.cpp	2015-08-03 13:17:13 +0000
@@ -64,8 +64,8 @@
 		  pTypeStr)
 {
 	texMapName = atexMapName;
-	lastOrbitJD =0;
-	deltaJD = StelCore::JD_SECOND;
+	lastOrbitJDE =0;
+	deltaJDE = StelCore::JD_SECOND;
 	orbitCached = 0;
 	closeOrbit = acloseOrbit;
 	semiMajorAxis = 0.;
@@ -143,7 +143,7 @@
 {
 	semiMajorAxis = value;
 	// GZ: in case we have very many asteroids, this helps improving speed usually without sacrificing accuracy:
-	deltaJD = 2.0*semiMajorAxis*StelCore::JD_SECOND;
+	deltaJDE = 2.0*semiMajorAxis*StelCore::JD_SECOND;
 }
 
 void MinorPlanet::setMinorPlanetNumber(int number)

=== modified file 'src/core/modules/Orbit.cpp'
--- src/core/modules/Orbit.cpp	2015-02-23 09:56:53 +0000
+++ src/core/modules/Orbit.cpp	2015-08-03 13:17:13 +0000
@@ -222,15 +222,6 @@
 	const double cj = cos(parentRotJ2000Longitude);
 	const double sj = sin(parentRotJ2000Longitude);
 
-//	rotateToVsop87[0] =  c_nod;
-//	rotateToVsop87[1] = -s_nod * c_obl;
-//	rotateToVsop87[2] =  s_nod * s_obl;
-//	rotateToVsop87[3] =  s_nod;
-//	rotateToVsop87[4] =  c_nod * c_obl;
-//	rotateToVsop87[5] = -c_nod * s_obl;
-//	rotateToVsop87[6] =  0.0;
-//	rotateToVsop87[7] =          s_obl;
-//	rotateToVsop87[8] =          c_obl;
 	rotateToVsop87[0] =  c_nod*cj-s_nod*c_obl*sj;
 	rotateToVsop87[1] = -c_nod*sj-s_nod*c_obl*cj;
 	rotateToVsop87[2] =           s_nod*s_obl;
@@ -243,20 +234,20 @@
 	//  qDebug() << "CometOrbit::()...done";
 }
 
-void CometOrbit::positionAtTimevInVSOP87Coordinates(double JD, double *v, bool updateVelocityVector)
+void CometOrbit::positionAtTimevInVSOP87Coordinates(double JDE, double *v, bool updateVelocityVector)
 {
-	JD -= t0;
+	JDE -= t0;
 	double rCosNu,rSinNu;
 //	temporary solve freezes for near-parabolic comets - using (e < 0.9999) for elliptical orbits
 //	TODO: improve calculations orbits for near-parabolic comets --AW
 //	if (e < 0.9999) InitEll(q,n,e,JD,a1,a2);
-	if (e < 1.0) InitEll(q,n,e,JD,rCosNu,rSinNu); // GZ: After solving with Laguerre-Conway, I dare to go for 1.0.
+	if (e < 1.0) InitEll(q,n,e,JDE,rCosNu,rSinNu); // GZ: After solving with Laguerre-Conway, I dare to go for 1.0.
 	else if (e > 1.0)
 	{
 		// qDebug() << "Hyperbolic orbit for ecc=" << e << ", i=" << i << ", w=" << w << ", Mean Motion n=" << n;
-		InitHyp(q,n,e,JD,rCosNu,rSinNu);
+		InitHyp(q,n,e,JDE,rCosNu,rSinNu);
 	}
-	else InitPar(q,n,JD,rCosNu,rSinNu);
+	else InitPar(q,n,JDE,rCosNu,rSinNu);
 	double p0,p1,p2, s0, s1, s2;
 	Init3D(i,Om,w,rCosNu,rSinNu,p0,p1,p2, s0, s1, s2, updateVelocityVector, e, q);
 	v[0] = rotateToVsop87[0]*p0 + rotateToVsop87[1]*p1 + rotateToVsop87[2]*p2;
@@ -475,34 +466,34 @@
 }
 
 // Return the offset from the center.
-Vec3d EllipticalOrbit::positionAtTime(const double JD) const
+Vec3d EllipticalOrbit::positionAtTime(const double JDE) const
 {
 	double meanMotion = 2.0 * M_PI / period;
-	double meanAnomaly = meanAnomalyAtEpoch + (JD-epoch) * meanMotion;
+	double meanAnomaly = meanAnomalyAtEpoch + (JDE-epoch) * meanMotion;
 	double E = eccentricAnomaly(meanAnomaly);
 
 	return positionAtE(E);
 }
 
-//void EllipticalOrbit::positionAtTime(double JD, double * X, double * Y, double * Z) const
+//void EllipticalOrbit::positionAtTime(double JDE, double * X, double * Y, double * Z) const
 //{
-//	Vec3d pos = positionAtTime(JD);
+//	Vec3d pos = positionAtTime(JDE);
 //	*X=pos[2];
 //	*Y=pos[0];
 //	*Z=pos[1];
 //}
 
-//void EllipticalOrbit::positionAtTimev(double JD, double* v)
+//void EllipticalOrbit::positionAtTimev(double JDE, double* v)
 //{
-//	Vec3d pos = positionAtTime(JD);
+//	Vec3d pos = positionAtTime(JDE);
 //	v[0]=pos[2];
 //	v[1]=pos[0];
 //	v[2]=pos[1];
 //}
 
-void EllipticalOrbit::positionAtTimevInVSOP87Coordinates(const double JD, double* v) const
+void EllipticalOrbit::positionAtTimevInVSOP87Coordinates(const double JDE, double* v) const
 {
-	Vec3d pos = positionAtTime(JD);
+	Vec3d pos = positionAtTime(JDE);
 	v[0] = rotateToVsop87[0]*pos[0] + rotateToVsop87[1]*pos[1] + rotateToVsop87[2]*pos[2];
 	v[1] = rotateToVsop87[3]*pos[0] + rotateToVsop87[4]*pos[1] + rotateToVsop87[5]*pos[2];
 	v[2] = rotateToVsop87[6]*pos[0] + rotateToVsop87[7]*pos[1] + rotateToVsop87[8]*pos[2];
@@ -529,12 +520,12 @@
 }
 
 
-Vec3d CachingOrbit::positionAtTime(double jd) const
+Vec3d CachingOrbit::positionAtTime(double JDE) const
 {
-	if (jd != lastTime)
+	if (JDE != lastTime)
 	{
-		lastTime = jd;
-		lastPosition = computePosition(jd);
+		lastTime = JDE;
+		lastPosition = computePosition(JDE);
 	}
 	return lastPosition;
 }

=== modified file 'src/core/modules/Orbit.hpp'
--- src/core/modules/Orbit.hpp	2015-02-23 09:56:53 +0000
+++ src/core/modules/Orbit.hpp	2015-08-03 13:17:13 +0000
@@ -51,10 +51,10 @@
 	// which is the reference frame for VSOP87
 	// In order to rotate to VSOP87
 	// parentRotObliquity and parentRotAscendingnode must be supplied.
-	void positionAtTimevInVSOP87Coordinates(const double JD, double* v) const;
+	void positionAtTimevInVSOP87Coordinates(const double JDE, double* v) const;
 
 	// Original one
-	Vec3d positionAtTime(const double JD) const;
+	Vec3d positionAtTime(const double JDE) const;
 	double getPeriod() const;
 	double getBoundingRadius() const;
 	virtual void sample(double, double, int, OrbitSampleProc&) const;
@@ -92,13 +92,13 @@
 		   );
 	// Compute the orbit for a specified Julian day and return a "stellarium compliant" function
 	// GZ: new optional variable: updateVelocityVector, true required for dust tail orientation!
-	void positionAtTimevInVSOP87Coordinates(double JD, double* v, bool updateVelocityVector=true);
+	void positionAtTimevInVSOP87Coordinates(double JDE, double* v, bool updateVelocityVector=true);
 	// updating the tails is a bit expensive. try not to overdo it.
 	bool getUpdateTails() const { return updateTails; }
 	void setUpdateTails(const bool update){ updateTails=update; }
-	//! return speed value [AU/d] last computed by positionAtTimevInVSOP87Coordinates(JD, v, true)
+	//! return speed value [AU/d] last computed by positionAtTimevInVSOP87Coordinates(JDE, v, true)
 	Vec3d getVelocity() const { return rdot; }
-	bool objectDateValid(const double JD) const { return (fabs(t0-JD)<orbitGood); }
+	bool objectDateValid(const double JDE) const { return (fabs(t0-JDE)<orbitGood); }
 private:
 	const double q;  //! perihel distance
 	const double e;  //! eccentricity
@@ -134,11 +134,11 @@
 public:
 	CachingOrbit() : lastTime(1.0e-30) {} //;
 
-	virtual Vec3d computePosition(double jd) const = 0;
+	virtual Vec3d computePosition(double JDE) const = 0;
 	virtual double getPeriod() const = 0;
 	virtual double getBoundingRadius() const = 0;
 
-	Vec3d positionAtTime(double jd) const;
+	Vec3d positionAtTime(double JDE) const;
 
 	virtual void sample(double, double, int, OrbitSampleProc& proc) const;
 

=== modified file 'src/core/modules/Planet.cpp'
--- src/core/modules/Planet.cpp	2015-07-28 13:20:32 +0000
+++ src/core/modules/Planet.cpp	2015-08-03 13:17:13 +0000
@@ -86,7 +86,7 @@
 	  axisRotation(0.),
 	  rings(NULL),
 	  sphereScale(1.f),
-	  lastJD(J2000),
+	  lastJDE(J2000),
 	  coordFunc(coordFunc),
 	  userDataPtr(auserDataPtr),
 	  osculatingFunc(osculatingFunc),
@@ -97,11 +97,11 @@
 {
 	texMapName = atexMapName;
 	normalMapName = anormalMapName;
-	lastOrbitJD =0;
-	deltaJD = StelCore::JD_SECOND;
+	lastOrbitJDE =0;
+	deltaJDE = StelCore::JD_SECOND;
 	orbitCached = 0;
 	closeOrbit = acloseOrbit;
-	deltaOrbitJD = 0;
+	deltaOrbitJDE = 0;
 	distance = 0;
 
 	// Initialize pType with the key found in pTypeMap, or mark planet type as undefined.
@@ -118,7 +118,7 @@
 	nativeName = "";
 	if (englishName!="Pluto")
 	{
-		deltaJD = 0.001*StelCore::JD_SECOND;
+		deltaJDE = 0.001*StelCore::JD_SECOND;
 	}
 	flagLabels = true;
 	flagNativeName = true;
@@ -383,7 +383,7 @@
 	re.precessionRate = _precessionRate;
 	re.siderealPeriod = _siderealPeriod;  // used for drawing orbit lines
 
-	deltaOrbitJD = re.siderealPeriod/ORBIT_SEGMENTS;
+	deltaOrbitJDE = re.siderealPeriod/ORBIT_SEGMENTS;
 }
 
 Vec3d Planet::getJ2000EquatorialPos(const StelCore *core) const
@@ -393,12 +393,12 @@
 
 // Compute the position in the parent Planet coordinate system
 // Actually call the provided function to compute the ecliptical position
-void Planet::computePositionWithoutOrbits(const double dateJD)
+void Planet::computePositionWithoutOrbits(const double dateJDE)
 {
-	if (fabs(lastJD-dateJD)>deltaJD)
+	if (fabs(lastJDE-dateJDE)>deltaJDE)
 	{
-		coordFunc(dateJD, eclipticPos, userDataPtr);
-		lastJD = dateJD;
+		coordFunc(dateJDE, eclipticPos, userDataPtr);
+		lastJDE = dateJDE;
 	}
 }
 
@@ -406,11 +406,11 @@
 // TODO: For earth, decide whether this should be Capitaine's omega_A (angle eclipticPoleJ2000//axis) or epsilon_A (angle axis//current ecliptic pole)
 // For now, it is epsilon_A, the angle between earth's rotational axis and mean ecliptic of date.
 // Details: e.g. Hilton etal, Report on Precession and the Ecliptic, Cel.Mech.Dyn.Astr.94:351-67 (2006), Fig1.
-double Planet::getRotObliquity(double JDay) const
+double Planet::getRotObliquity(double JDE) const
 {
 	// JDay=2451545.0 for J2000.0
 	if (englishName=="Earth")
-		return get_mean_ecliptical_obliquity(JDay) *M_PI/180.0;
+		return get_mean_ecliptical_obliquity(JDE) *M_PI/180.0;
 	else
 		return re.obliquity;
 }
@@ -459,28 +459,30 @@
 	return res;
 }
 
-void Planet::computePosition(const double dateJD)
+void Planet::computePosition(const double dateJDE)
 {
 	// Make sure the parent position is computed for the dateJD, otherwise
 	// getHeliocentricPos() would return incorect values.
 	if (parent)
-		parent->computePositionWithoutOrbits(dateJD);
+		parent->computePositionWithoutOrbits(dateJDE);
 
-	if (orbitFader.getInterstate()>0.000001 && deltaOrbitJD > 0 && (fabs(lastOrbitJD-dateJD)>deltaOrbitJD || !orbitCached))
+	if (orbitFader.getInterstate()>0.000001 && deltaOrbitJDE > 0 && (fabs(lastOrbitJDE-dateJDE)>deltaOrbitJDE || !orbitCached))
 	{
+		StelCore *core=StelApp::getInstance().getCore();
+
 		double calc_date;
 		// int delta_points = (int)(0.5 + (date - lastOrbitJD)/date_increment);
 		int delta_points;
 
-		if( dateJD > lastOrbitJD )
+		if( dateJDE > lastOrbitJDE )
 		{
-			delta_points = (int)(0.5 + (dateJD - lastOrbitJD)/deltaOrbitJD);
+			delta_points = (int)(0.5 + (dateJDE - lastOrbitJDE)/deltaOrbitJDE);
 		}
 		else
 		{
-			delta_points = (int)(-0.5 + (dateJD - lastOrbitJD)/deltaOrbitJD);
+			delta_points = (int)(-0.5 + (dateJDE - lastOrbitJDE)/deltaOrbitJDE);
 		}
-		double new_date = lastOrbitJD + delta_points*deltaOrbitJD;
+		double new_date = lastOrbitJDE + delta_points*deltaOrbitJDE;
 
 		// qDebug( "Updating orbit coordinates for %s (delta %f) (%d points)\n", getEnglishName().toUtf8().data(), deltaOrbitJD, delta_points);
 
@@ -492,13 +494,13 @@
 				if(d + delta_points >= ORBIT_SEGMENTS )
 				{
 					// calculate new points
-					calc_date = new_date + (d-ORBIT_SEGMENTS/2)*deltaOrbitJD;
+					calc_date = new_date + (d-ORBIT_SEGMENTS/2)*deltaOrbitJDE;
 
 					// date increments between points will not be completely constant though
-					computeTransMatrix(calc_date);
+					computeTransMatrix(calc_date-core->computeDeltaT(calc_date)/86400.0, calc_date);
 					if (osculatingFunc)
 					{
-						(*osculatingFunc)(dateJD,calc_date,eclipticPos);
+						(*osculatingFunc)(dateJDE,calc_date,eclipticPos);
 					}
 					else
 					{
@@ -514,7 +516,7 @@
 				}
 			}
 
-			lastOrbitJD = new_date;
+			lastOrbitJDE = new_date;
 		}
 		else if( delta_points < 0 && abs(delta_points) < ORBIT_SEGMENTS  && orbitCached)
 		{
@@ -524,11 +526,11 @@
 				if(d + delta_points < 0 )
 				{
 					// calculate new points
-					calc_date = new_date + (d-ORBIT_SEGMENTS/2)*deltaOrbitJD;
+					calc_date = new_date + (d-ORBIT_SEGMENTS/2)*deltaOrbitJDE;
 
-					computeTransMatrix(calc_date);
+					computeTransMatrix(calc_date-core->computeDeltaT(calc_date)/86400.0, calc_date);
 					if (osculatingFunc) {
-						(*osculatingFunc)(dateJD,calc_date,eclipticPos);
+						(*osculatingFunc)(dateJDE,calc_date,eclipticPos);
 					}
 					else
 					{
@@ -544,7 +546,7 @@
 				}
 			}
 
-			lastOrbitJD = new_date;
+			lastOrbitJDE = new_date;
 
 		}
 		else if( delta_points || !orbitCached)
@@ -553,11 +555,11 @@
 			// update all points (less efficient)
 			for( int d=0; d<ORBIT_SEGMENTS; d++ )
 			{
-				calc_date = dateJD + (d-ORBIT_SEGMENTS/2)*deltaOrbitJD;
-				computeTransMatrix(calc_date);
+				calc_date = dateJDE + (d-ORBIT_SEGMENTS/2)*deltaOrbitJDE;
+				computeTransMatrix(calc_date-core->computeDeltaT(calc_date)/86400.0, calc_date);
 				if (osculatingFunc)
 				{
-					(*osculatingFunc)(dateJD,calc_date,eclipticPos);
+					(*osculatingFunc)(dateJDE,calc_date,eclipticPos);
 				}
 				else
 				{
@@ -567,36 +569,36 @@
 				orbit[d] = getHeliocentricEclipticPos();
 			}
 
-			lastOrbitJD = dateJD;
+			lastOrbitJDE = dateJDE;
 			if (!osculatingFunc) orbitCached = 1;
 		}
 
 
 		// calculate actual Planet position
-		coordFunc(dateJD, eclipticPos, userDataPtr);
+		coordFunc(dateJDE, eclipticPos, userDataPtr);
 
-		lastJD = dateJD;
+		lastJDE = dateJDE;
 
 	}
-	else if (fabs(lastJD-dateJD)>deltaJD)
+	else if (fabs(lastJDE-dateJDE)>deltaJDE)
 	{
 		// calculate actual Planet position
-		coordFunc(dateJD, eclipticPos, userDataPtr);
+		coordFunc(dateJDE, eclipticPos, userDataPtr);
 		// XXX: do we need to do that even when the orbit is not visible?
 		for( int d=0; d<ORBIT_SEGMENTS; d++ )
 			orbit[d]=getHeliocentricPos(orbitP[d]);
-		lastJD = dateJD;
+		lastJDE = dateJDE;
 	}
 
 }
 
 // Compute the transformation matrix from the local Planet coordinate system to the parent Planet coordinate system.
-// In case of the planets, this makes the axis point to the respective celestial pole.
+// In case of the planets, this makes the axis point to their respective celestial poles.
 // TODO: Verify for the other planets if their axes are relative to J2000 ecliptic (VSOP87A XY plane) or relative to (precessed) ecliptic of date?
-void Planet::computeTransMatrix(double jd)
+void Planet::computeTransMatrix(double JD, double JDE)
 {
-	// TODO: correct this for earth with the new model.
-	axisRotation = getSiderealTime(jd);
+	// We have to call with both to correct this for earth with the new model.
+	axisRotation = getSiderealTime(JD, JDE);
 
 	// Special case - heliocentric coordinates are relative to eclipticJ2000 (VSOP87A XY plane),
 	// not solar equator...
@@ -611,7 +613,7 @@
 			// ADS: 2011A&A...534A..22V = A&A 534, A22 (2011): Vondrak, Capitane, Wallace: New Precession Expressions, valid for long time intervals:
 			// See also Hilton et al, Report on Precession and the Ecliptic. Cel.Mech.Dyn.Astr. 94:351-367 (2006).
 			double eps_A, chi_A, omega_A, psi_A;
-			getPrecessionAnglesVondrak(jd, &eps_A, &chi_A, &omega_A, &psi_A);
+			getPrecessionAnglesVondrak(JDE, &eps_A, &chi_A, &omega_A, &psi_A);
 			// GZ This is the right combination for precession of the equator: Nodal rotation psi_A,
 			// then rotation by omega_A, the angle between EclPoleJ2000 and EarthPoleOfDate.
 			// The final rotation by chi_A rotates the equinox (zero degree).
@@ -619,7 +621,7 @@
 			rotLocalToParent= Mat4d::zrotation(-psi_A) * Mat4d::xrotation(-omega_A) * Mat4d::zrotation(chi_A);
 		  }
 		else
-			rotLocalToParent = Mat4d::zrotation(re.ascendingNode - re.precessionRate*(jd-re.epoch)) * Mat4d::xrotation(re.obliquity);
+			rotLocalToParent = Mat4d::zrotation(re.ascendingNode - re.precessionRate*(JDE-re.epoch)) * Mat4d::xrotation(re.obliquity);
 	}
 }
 
@@ -646,15 +648,16 @@
 }
 
 
-// Compute the z rotation to use from equatorial to geographic coordinates
-double Planet::getSiderealTime(double jd) const
+// Compute the z rotation to use from equatorial to geographic coordinates.
+// We need both JD and JDE here: For Earth we use JD(UT), for other planets JDE(TT).
+double Planet::getSiderealTime(double JD, double JDE) const
 {
 	if (englishName=="Earth")
 	{	// GZ I wanted to be sure that nutation is just those ignorable few arcseconds.
 		//qDebug() << "Difference apparent-mean sidereal times (s): " << (get_apparent_sidereal_time(jd)- get_mean_sidereal_time(jd))* 240.0; // 1degree=4min=240s.
 		// TODO: Reactivate Nutation (but following IAU-2000A) after fixing JD_UT/JD_ET issues, then change this call back to apparent_sidereal_time.
 		//return get_apparent_sidereal_time(jd);
-		return get_mean_sidereal_time(jd);
+		return get_mean_sidereal_time(JD);
 
 		// In the newer precession/nutation literature (starting around 2006) there are two sets of algorithms:
 		// "Classical" sidereal time (Greenwich hour angle GHA) and a solution based on Earth Rotational Angle ERA.
@@ -663,7 +666,7 @@
 
 	}
 
-	double t = jd - re.epoch;
+	double t = JDE - re.epoch;
 	// oops... avoid division by zero (typical case for moons with chaotic period of rotation)
 	double rotations = 1.f; // NOTE: Maybe 1e-3 will be better?
 	if (re.period!=0.) // OK, it's not a moon with chaotic period of rotation :)
@@ -679,24 +682,24 @@
 		{
 			// use semi-empirical coefficient for GRS drift
 			// qDebug() << "Jupiter: offset = " << re.offset << " --> rotation = " << (remainder * 360. + re.offset - 0.2483 * qAbs(jd - 2456172));
-			return remainder * 360. + re.offset - 0.2483 * qAbs(jd - 2456172);
+			return remainder * 360. + re.offset - 0.2483 * qAbs(JDE - 2456172);
 		}
 		else
 		{
 			// http://www.projectpluto.com/grs_form.htm
 			// CM( System II) =  181.62 + 870.1869147 * jd + correction [870d rotation every day]
 			const double rad  = M_PI/180.;
-			double jup_mean = (jd - 2455636.938) * 360. / 4332.89709;
+			double jup_mean = (JDE - 2455636.938) * 360. / 4332.89709;
 			double eqn_center = 5.55 * sin( rad*jup_mean);
-			double angle = (jd - 2451870.628) * 360. / 398.884 - eqn_center;
+			double angle = (JDE - 2451870.628) * 360. / 398.884 - eqn_center;
 			//double correction = 11 * sin( rad*angle) + 5 * cos( rad*angle)- 1.25 * cos( rad*jup_mean) - eqn_center; // original correction
 			double correction = 25.8 + 11 * sin( rad*angle) - 2.5 * cos( rad*jup_mean) - eqn_center; // light speed correction not used because in stellarium the jd is manipulated for that
-			double cm2=181.62 + 870.1869147 * jd + correction;
+			double cm2=181.62 + 870.1869147 * JDE + correction; // Central Meridian II
 			cm2=cm2 - 360.0*(int)(cm2/360.);
 			// http://www.skyandtelescope.com/observing/transit-times-of-jupiters-great-red-spot/ writes:
 			// The predictions assume the Red Spot was at Jovian System II longitude 216° in September 2014 and continues to drift 1.25° per month, based on historical trends noted by JUPOS.
 			// GRS longitude was at 2014-09-08 216d with a drift of 1.25d every month
-			double longitudeGRS=216+1.25*( jd - 2456908)/30;
+			double longitudeGRS=216+1.25*( JDE - 2456908)/30;
 			// qDebug() << "Jupiter: CM2 = " << cm2 << " longitudeGRS = " << longitudeGRS << " --> rotation = " << (cm2 - longitudeGRS);
 			return cm2 - longitudeGRS + 25.; // + 25 = Jupiter Texture not 0d
 			// To verify:
@@ -799,7 +802,7 @@
 	distance = (obsHelioPos-getHeliocentricEclipticPos()).length();
 	// improve fps by juggling updates for asteroids. They must be fast if close to observer, but can be slow if further away.
 	if (pType == Planet::isAsteroid)
-			deltaJD=distance*StelCore::JD_SECOND;
+			deltaJDE=distance*StelCore::JD_SECOND;
 	return distance;
 }
 
@@ -929,8 +932,8 @@
 				{
 					// add rings computation
 					// implemented from Meeus, Astr.Alg.1992
-					const double jd=core->getJDay();
-					const double T=(jd-2451545.0)/36525.0;
+					const double jde=core->getJDE();
+					const double T=(jde-2451545.0)/36525.0;
 					const double i=((0.000004*T-0.012998)*T+28.075216)*M_PI/180.0;
 					const double Omega=((0.000412*T+1.394681)*T+169.508470)*M_PI/180.0;
 					static SolarSystem *ssystem=GETSTELMODULE(SolarSystem);
@@ -968,8 +971,8 @@
 				{
 					// add rings computation
 					// implemented from Meeus, Astr.Alg.1992
-					const double jd=core->getJDay();
-					const double T=(jd-2451545.0)/36525.0;
+					const double jde=core->getJDE();
+					const double T=(jde-2451545.0)/36525.0;
 					const double i=((0.000004*T-0.012998)*T+28.075216)*M_PI/180.0;
 					const double Omega=((0.000412*T+1.394681)*T+169.508470)*M_PI/180.0;
 					SolarSystem *ssystem=GETSTELMODULE(SolarSystem);
@@ -1006,8 +1009,8 @@
 				{
 					// add rings computation
 					// implemented from Meeus, Astr.Alg.1992
-					const double jd=core->getJDay();
-					const double T=(jd-2451545.0)/36525.0;
+					const double jde=core->getJDE();
+					const double T=(jde-2451545.0)/36525.0;
 					const double i=((0.000004*T-0.012998)*T+28.075216)*M_PI/180.0;
 					const double Omega=((0.000412*T+1.394681)*T+169.508470)*M_PI/180.0;
 					static SolarSystem *ssystem=GETSTELMODULE(SolarSystem);

=== modified file 'src/core/modules/Planet.hpp'
--- src/core/modules/Planet.hpp	2015-07-27 13:25:39 +0000
+++ src/core/modules/Planet.hpp	2015-08-03 13:17:13 +0000
@@ -33,7 +33,7 @@
 // The last variable is the userData pointer.
 typedef void (*posFuncType)(double, double*, void*);
 
-typedef void (OsculatingFunctType)(double jd0,double jd,double xyz[3]);
+typedef void (OsculatingFunctType)(double jde0,double jde,double xyz[3]);
 
 // epoch J2000: 12 UT on 1 Jan 2000
 #define J2000 2451545.0
@@ -51,7 +51,7 @@
 	RotationElements(void) : period(1.), offset(0.), epoch(J2000), obliquity(0.), ascendingNode(0.), precessionRate(0.), siderealPeriod(0.) {}
 	float period;          // (sidereal) rotation period [earth days]
 	float offset;          // rotation at epoch  [degrees]
-	double epoch;          // JD (TD) of epoch for these elements
+	double epoch;          // JDE (JD TT) of epoch for these elements
 	float obliquity;       // tilt of rotation axis w.r.t. ecliptic [radians]
 	float ascendingNode;   // long. of ascending node of equator on the ecliptic [radians]
 	float precessionRate;  // rate of precession of rotation axis in [rads/JulianCentury(36525d)]
@@ -192,20 +192,22 @@
 	const QString getApparentMagnitudeAlgorithmString() const { return vMagAlgorithmMap.value(vMagAlgorithm); }
 	void setApparentMagnitudeAlgorithm(QString algorithm);
 
-	// Compute the z rotation to use from equatorial to geographic coordinates
-	double getSiderealTime(double jd) const;
+	//! Compute the z rotation to use from equatorial to geographic coordinates. For general applicability we need both time flavours:
+	//! @param JD is JD(UT) for Earth
+	//! @param JDE is used for other locations
+	double getSiderealTime(double JD, double JDE) const;
 	Mat4d getRotEquatorialToVsop87(void) const;
 	void setRotEquatorialToVsop87(const Mat4d &m);
 
 	const RotationElements &getRotationElements(void) const {return re;}
 
 	// Compute the position in the parent Planet coordinate system
-	void computePositionWithoutOrbits(const double dateJD);
-	//virtual void computePosition(const double dateJD);// GZ: gets overridden in Comet!
-	void computePosition(const double dateJD);// GZ: gets overridden in Comet!
+	void computePositionWithoutOrbits(const double dateJDE);
+	void computePosition(const double dateJDE);
 
-	// Compute the transformation matrix from the local Planet coordinate to the parent Planet coordinate
-	void computeTransMatrix(double date);
+	// Compute the transformation matrix from the local Planet coordinate to the parent Planet coordinate.
+	// This requires both flavours of JD in cases involving Earth.
+	void computeTransMatrix(double JD, double JDE);
 
 	// Get the phase angle (rad) for an observer at pos obsPos in heliocentric coordinates (in AU)
 	double getPhaseAngle(const Vec3d& obsPos) const;
@@ -223,7 +225,7 @@
 	double getRotAscendingnode(void) const {return re.ascendingNode;}
 	// return angle between axis and normal of ecliptic plane (or, for a moon, equatorial/reference plane defined by parent).
 	// TODO: decide if this is always angle between axis and J2000 ecliptic, or should be axis//current ecliptic!
-	double getRotObliquity(double JDay) const;
+	double getRotObliquity(double JDE) const;
 
 	//! Get the Planet position in the parent Planet ecliptic coordinate in AU
 	Vec3d getEclipticPos() const;
@@ -277,9 +279,9 @@
 	void drawOrbit(const StelCore*);
 	Vec3d orbit[ORBIT_SEGMENTS+1];   // store heliocentric coordinates for drawing the orbit
 	Vec3d orbitP[ORBIT_SEGMENTS+1];  // store local coordinate for orbit
-	double lastOrbitJD;
-	double deltaJD;                  // time difference between positional updates.
-	double deltaOrbitJD;
+	double lastOrbitJDE;
+	double deltaJDE;                 // time difference between positional updates.
+	double deltaOrbitJDE;
 	bool orbitCached;                // whether orbit calculations are cached for drawing orbit yet
 	bool closeOrbit;                 // whether to connect the beginning of the orbit line to
 					 // the end: good for elliptical orbits, bad for parabolic
@@ -336,8 +338,8 @@
 	double distance;                 // Temporary variable used to store the distance to a given point
 					 // it is used for sorting while drawing
 	float sphereScale;               // Artificial scaling for better viewing
-	double lastJD;                   // caches JD of last positional computation
-	// The callback for the calculation of the equatorial rect heliocentric position at time JD.
+	double lastJDE;                  // caches JDE of last positional computation
+	// The callback for the calculation of the equatorial rect heliocentric position at time JDE.
 	posFuncType coordFunc;
 	void* userDataPtr;               // this is always used with an Orbit object.
 

=== modified file 'src/core/modules/SolarSystem.cpp'
--- src/core/modules/SolarSystem.cpp	2015-07-27 14:57:16 +0000
+++ src/core/modules/SolarSystem.cpp	2015-08-03 13:17:13 +0000
@@ -1024,47 +1024,49 @@
 
 // Compute the position for every elements of the solar system.
 // The order is not important since the position is computed relatively to the mother body
-void SolarSystem::computePositions(double date, const Vec3d& observerPos)
+void SolarSystem::computePositions(double dateJDE, const Vec3d& observerPos)
 {
 	if (flagLightTravelTime)
 	{
 		foreach (PlanetP p, systemPlanets)
 		{
-			p->computePositionWithoutOrbits(date);
+			p->computePositionWithoutOrbits(dateJDE);
 		}
 		foreach (PlanetP p, systemPlanets)
 		{
 			const double light_speed_correction = (p->getHeliocentricEclipticPos()-observerPos).length() * (AU / (SPEED_OF_LIGHT * 86400));
-			p->computePosition(date-light_speed_correction);
+			p->computePosition(dateJDE-light_speed_correction);
 		}
 	}
 	else
 	{
 		foreach (PlanetP p, systemPlanets)
 		{
-			p->computePosition(date);
+			p->computePosition(dateJDE);
 		}
 	}
-	computeTransMatrices(date, observerPos);
+	computeTransMatrices(dateJDE, observerPos);
 }
 
 // Compute the transformation matrix for every elements of the solar system.
 // The elements have to be ordered hierarchically, eg. it's important to compute earth before moon.
-void SolarSystem::computeTransMatrices(double date, const Vec3d& observerPos)
+void SolarSystem::computeTransMatrices(double dateJDE, const Vec3d& observerPos)
 {
+	double dateJD=dateJDE - (StelApp::getInstance().getCore()->computeDeltaT(dateJDE))/86400.0;
+
 	if (flagLightTravelTime)
 	{
 		foreach (PlanetP p, systemPlanets)
 		{
 			const double light_speed_correction = (p->getHeliocentricEclipticPos()-observerPos).length() * (AU / (SPEED_OF_LIGHT * 86400));
-			p->computeTransMatrix(date-light_speed_correction);
+			p->computeTransMatrix(dateJD-light_speed_correction, dateJDE-light_speed_correction);
 		}
 	}
 	else
 	{
 		foreach (PlanetP p, systemPlanets)
 		{
-			p->computeTransMatrix(date);
+			p->computeTransMatrix(dateJD, dateJDE);
 		}
 	}
 }

=== modified file 'src/core/modules/SolarSystem.hpp'
--- src/core/modules/SolarSystem.hpp	2015-07-05 19:48:33 +0000
+++ src/core/modules/SolarSystem.hpp	2015-08-03 13:17:13 +0000
@@ -342,9 +342,9 @@
 
 	//! Compute the position and transform matrix for every element of the solar system.
 	//! @param observerPos Position of the observer in heliocentric ecliptic frame (Required for light travel time computation).
-	//! @param date the date in JDay
+	//! @param dateJDE the Julian Day in JDE (Ephemeris Time or equivalent)
 	//! \deprecated ??? In the "deprecated" section, but used in SolarSystem::init()
-	void computePositions(double date, const Vec3d& observerPos = Vec3d(0.));
+	void computePositions(double dateJDE, const Vec3d& observerPos = Vec3d(0.));
 
 	//! Get the list of all the bodies of the solar system.
 	//! \deprecated Used in LandscapeMgr::update(), but commented out.
@@ -372,7 +372,7 @@
 
 	//! Compute the transformation matrix for every elements of the solar system.
 	//! observerPos is needed for light travel time computation.
-	void computeTransMatrices(double date, const Vec3d& observerPos = Vec3d(0.));
+	void computeTransMatrices(double dateJDE, const Vec3d& observerPos = Vec3d(0.));
 
 	//! Draw a nice animated pointer around the object.
 	void drawPointer(const StelCore* core);

=== modified file 'src/core/modules/StarWrapper.cpp'
--- src/core/modules/StarWrapper.cpp	2015-06-12 18:45:39 +0000
+++ src/core/modules/StarWrapper.cpp	2015-08-03 13:17:13 +0000
@@ -247,7 +247,7 @@
 		{
 			// Calculate next minimum or maximum light
 			double vsEpoch = 2400000+vEpoch;
-			double npDate = vsEpoch + vPeriod * ::floor(1.0 + (core->getJDay() - vsEpoch)/vPeriod);
+			double npDate = vsEpoch + vPeriod * ::floor(1.0 + (core->getJDE() - vsEpoch)/vPeriod);
 			QString nextDate = StelUtils::julianDayToISO8601String(npDate).replace("T", " ");
 			if (ebsFlag)
 				oss << q_("Next minimum light: %1 UTC").arg(nextDate) << "<br />";

=== modified file 'src/core/modules/StarWrapper.hpp'
--- src/core/modules/StarWrapper.hpp	2015-01-02 16:18:33 +0000
+++ src/core/modules/StarWrapper.hpp	2015-08-03 13:17:13 +0000
@@ -77,7 +77,7 @@
 	{
 		static const double d2000 = 2451545.0;
 		Vec3f v;
-		s->getJ2000Pos(z, (M_PI/180.)*(0.0001/3600.) * ((core->getJDay()-d2000)/365.25) / a->star_position_scale, v);
+		s->getJ2000Pos(z, (M_PI/180.)*(0.0001/3600.) * ((core->getJDE()-d2000)/365.25) / a->star_position_scale, v);
 		return Vec3d(v[0], v[1], v[2]);
 	}
 	Vec3f getInfoColor(void) const

=== modified file 'src/core/modules/ZodiacalLight.cpp'
--- src/core/modules/ZodiacalLight.cpp	2015-06-30 18:34:14 +0000
+++ src/core/modules/ZodiacalLight.cpp	2015-08-03 13:17:13 +0000
@@ -93,7 +93,7 @@
 	// Test if we are not on Earth. Texture would not fit, so don't draw then.
 	if (core->getCurrentLocation().planetName != "Earth") return;
 
-	double currentJD=core->getJDay();
+	double currentJD=core->getJD();
 	if (qAbs(currentJD - lastJD) > 0.25f) // should be enough to update position every 6 hours.
 	{
 		// update vertices

=== modified file 'src/core/modules/ZoneArray.cpp'
--- src/core/modules/ZoneArray.cpp	2015-02-08 15:35:27 +0000
+++ src/core/modules/ZoneArray.cpp	2015-08-03 13:17:13 +0000
@@ -467,7 +467,7 @@
 	StelSkyDrawer* drawer = core->getSkyDrawer();
 	Vec3f vf;
 	static const double d2000 = 2451545.0;
-	const float movementFactor = (M_PI/180)*(0.0001/3600) * ((core->getJDay()-d2000)/365.25) / star_position_scale;
+	const float movementFactor = (M_PI/180)*(0.0001/3600) * ((core->getJDE()-d2000)/365.25) / star_position_scale;
 
 	// GZ, added for extinction
 	const Extinction& extinction=core->getSkyDrawer()->getExtinction();
@@ -549,7 +549,7 @@
 					  QList<StelObjectP > &result)
 {
 	static const double d2000 = 2451545.0;
-	const double movementFactor = (M_PI/180.)*(0.0001/3600.) * ((core->getJDay()-d2000)/365.25)/ star_position_scale;
+	const double movementFactor = (M_PI/180.)*(0.0001/3600.) * ((core->getJDE()-d2000)/365.25)/ star_position_scale;
 	const SpecialZoneData<Star> *const z = getZones()+index;
 	Vec3f tmp;
 	Vec3f vf(v[0], v[1], v[2]);

=== modified file 'src/core/planetsephems/sidereal_time.c'
--- src/core/planetsephems/sidereal_time.c	2015-07-27 11:16:32 +0000
+++ src/core/planetsephems/sidereal_time.c	2015-08-03 13:17:13 +0000
@@ -209,18 +209,18 @@
 	{-3.0,	0.0,	0.0,	0.0}};
 
 /* cache values */
-static double c_JD = 0.0, c_longitude = 0.0, c_obliquity = 0.0, c_ecliptic = 0.0; 
+static double c_JDE = 0.0, c_longitude = 0.0, c_obliquity = 0.0, c_ecliptic = 0.0;
 
 
 /* Calculate nutation of longitude and obliquity in degrees from Julian Ephemeris Day
-* params : JD Julian Day, nutation Pointer to store nutation.
+* params : JDE Julian Day (ET/TT), nutation Pointer to store nutation.
 * Meeus, Astr. Alg. (1st ed., 1994), Chapter 21 pg 131-134 Using Table 21A */
 /* GZ: Changed: ecliptic obliquity used to be constant J2000.0. 
  * If you don't compute this, you may as well forget about nutation!
  * 2015: Laskar's 1986 formula replaced by Vondrak 2011. c_ecliptic is now epsilon_A, Vondrak's obliquity of date.
  * TODO: replace this whole function with Nutation IAU2000A or compatible version.
  */
-void get_nutation (double JD, struct ln_nutation * nutation)
+void get_nutation (double JDE, struct ln_nutation * nutation)
 {
 
 	double D,M,MM,F,O,T;
@@ -228,16 +228,16 @@
 	int i;
 
 	/* should we bother recalculating nutation */
-	if (fabs(JD - c_JD) > LN_NUTATION_EPOCH_THRESHOLD)
+	if (fabs(JDE - c_JDE) > LN_NUTATION_EPOCH_THRESHOLD)
 	  {
 		/* set the new epoch */
-		c_JD = JD;
+		c_JDE = JDE;
 
 		/* set ecliptic. GZ: This is constant only, J2000.0. WRONG! */
 		/* c_ecliptic = 23.0 + 26.0 / 60.0 + 27.407 / 3600.0; */
 
 		/* calc T */
-		T = (JD - 2451545.0)/36525;
+		T = (JDE - 2451545.0)/36525;
 		/* GZotti: we don't need those. * /
 		T2 = T * T;
 		T3 = T2 * T;
@@ -361,7 +361,7 @@
 /* Calculate the apparent sidereal time at the meridian of Greenwich of a given date.
  * returns apparent sidereal time (degrees).
  * Formula 11.1, 11.4 pg 83 */
-double get_apparent_sidereal_time (double JD)
+double get_apparent_sidereal_time (double JD, double JDE)
 {
 	double correction, sidereal;
 	struct ln_nutation nutation;
@@ -371,9 +371,9 @@
 	/* get the mean sidereal time */
 	sidereal = get_mean_sidereal_time (JD);
         
-	/* add corrections for nutation in longitude and for the true obliquity of
-	the ecliptic */
-	get_nutation (JD, &nutation);
+	/* add corrections for nutation in longitude and for the true obliquity of the ecliptic
+	 */
+	get_nutation (JDE, &nutation);
     
 	/* GZ: This was the only place where this was used. I added the summation here. */
 	correction = (nutation.deltaPsi * cos ((nutation.ecliptic+nutation.deltaEps)*M_PI/180.));

=== modified file 'src/core/planetsephems/sidereal_time.h'
--- src/core/planetsephems/sidereal_time.h	2014-02-05 17:01:25 +0000
+++ src/core/planetsephems/sidereal_time.h	2015-08-03 13:17:13 +0000
@@ -28,8 +28,8 @@
 /* Calculate mean sidereal time from date. */
 double get_mean_sidereal_time (double JD);
 
-/* Calculate apparent sidereal time from date.*/
-double get_apparent_sidereal_time (double JD);
+/* Calculate apparent sidereal time from date. We need JD(UT) and JDE(TT) here to accurately compute nutation. */
+double get_apparent_sidereal_time (double JD, double JDE);
 /* Calculate mean ecliptical obliquity in degrees. */
 double get_mean_ecliptical_obliquity(double JDE);
 /* Calculate nutation in longitude in degrees. */

=== modified file 'src/gui/ConfigurationDialog.cpp'
--- src/gui/ConfigurationDialog.cpp	2015-07-27 14:57:16 +0000
+++ src/gui/ConfigurationDialog.cpp	2015-08-03 13:17:13 +0000
@@ -931,8 +931,8 @@
 void ConfigurationDialog::setFixedDateTimeToCurrent(void)
 {
 	StelCore* core = StelApp::getInstance().getCore();
-	double JD = core->getJDay();
-	ui->fixedDateTimeEdit->setDateTime(StelUtils::jdToQDateTime(JD+StelUtils::getGMTShiftFromQT(JD)/24-core->getDeltaT(JD)/86400));
+	double JD = core->getJD();
+	ui->fixedDateTimeEdit->setDateTime(StelUtils::jdToQDateTime(JD+StelUtils::getGMTShiftFromQT(JD)/24));
 	ui->fixedTimeRadio->setChecked(true);
 	setStartupTimeMode();
 }
@@ -1252,6 +1252,8 @@
 	algorithms->addItem(q_("Morrison & Stephenson (2004, 2005)"), "MorrisonStephenson2004");
 	// Espenak & Meeus (2006) used by default
 	algorithms->addItem(q_("Espenak & Meeus (2006)").append(" *"), "EspenakMeeus");
+	// GZ: I want to try out some things. Something is still wrong with eclipses, see lp:1275092.
+	//algorithms->addItem(q_("Espenak & Meeus (2006) no extra moon acceleration"), "EspenakMeeusZeroMoonAccel");
 	algorithms->addItem(q_("Reijs (2006)"), "Reijs");
 	algorithms->addItem(q_("Banjevic (2006)"), "Banjevic");
 	algorithms->addItem(q_("Islam, Sadiq & Qureshi (2008, 2013)"), "IslamSadiqQureshi");

=== modified file 'src/gui/DateTimeDialog.cpp'
--- src/gui/DateTimeDialog.cpp	2015-02-05 15:36:01 +0000
+++ src/gui/DateTimeDialog.cpp	2015-08-03 13:17:13 +0000
@@ -54,13 +54,9 @@
 void DateTimeDialog::createDialogContent()
 {
 	ui->setupUi(dialog);
-	double cjd = StelApp::getInstance().getCore()->getJDay();
+	double jd = StelApp::getInstance().getCore()->getJD();
 	// UTC -> local tz
-	// Add in a DeltaT correction. Divide DeltaT by 86400 to convert from seconds to days.
-	double deltaT = 0.;
-	if (StelApp::getInstance().getCore()->getCurrentLocation().planetName=="Earth")
-		deltaT = StelApp::getInstance().getCore()->getDeltaT(cjd)/86400.;
-	setDateTime(cjd + (StelApp::getInstance().getLocaleMgr().getGMTShift(cjd)/24.0)-deltaT);
+	setDateTime(jd + (StelApp::getInstance().getLocaleMgr().getGMTShift(jd)/24.0));
 
 	connect(&StelApp::getInstance(), SIGNAL(languageChanged()), this, SLOT(retranslate()));
 	connect(ui->closeStelWindow, SIGNAL(clicked()), this, SLOT(close()));
@@ -115,15 +111,15 @@
 	minute = dmin;
 	second = ds;
 	pushToWidgets();
-	StelApp::getInstance().getCore()->setJDay(newJd());
+	StelApp::getInstance().getCore()->setJD(newJd());
 	return true;
 }
 
 bool DateTimeDialog::validJd(double jday)
 {
 	pushToWidgets();
-	StelCore *core = StelApp::getInstance().getCore();
-	core->setJDay(jday+core->getDeltaT(jday)/86400.);
+	StelApp::getInstance().getCore()->setJD(jday);
+
 	return true;
 }
 
@@ -211,11 +207,8 @@
 {
 	double cjd;
 	StelUtils::getJDFromDate(&cjd, year, month, day, hour, minute, second);
-	// Add in a DeltaT correction. Divide DeltaT by 86400 to convert from seconds to days.
-	double deltaT = 0.;
-	if (StelApp::getInstance().getCore()->getCurrentLocation().planetName=="Earth")
-		deltaT = StelApp::getInstance().getCore()->getDeltaT(cjd)/86400.;
-	cjd -= (StelApp::getInstance().getLocaleMgr().getGMTShift(cjd)/24.0-deltaT); // local tz -> UTC
+	cjd -= (StelApp::getInstance().getLocaleMgr().getGMTShift(cjd)/24.0); // local tz -> UTC
+
 	return cjd;
 }
 
@@ -236,25 +229,25 @@
 	}
 	ui->spinner_jd->setValue(jd);
 	ui->spinner_mjd->setValue(mjd);
+	if (jd<2299161) // 1582-10-15
+		ui->dateTimeTab->setToolTip(q_("Date and Time in Julian calendar"));
+	else
+		ui->dateTimeTab->setToolTip(q_("Date and Time in Gregorian calendar"));
 	connectSpinnerEvents();
 }
 
 /************************************************************************
-Send newJd to spinner_*
+Prepare date elements from newJd and send to spinner_*
  ************************************************************************/
 void DateTimeDialog::setDateTime(double newJd)
 {
 	if (this->visible()) {
-		// Add in a DeltaT correction. Divide DeltaT by 86400 to convert from seconds to days.
-		double deltaT = 0.;
-		if (StelApp::getInstance().getCore()->getCurrentLocation().planetName=="Earth")
-			deltaT = StelApp::getInstance().getCore()->getDeltaT(newJd)/86400.;
-		double newJdC = newJd - deltaT;
-		newJd += (StelApp::getInstance().getLocaleMgr().getGMTShift(newJd)/24.0-deltaT); // UTC -> local tz
+		newJd += (StelApp::getInstance().getLocaleMgr().getGMTShift(newJd)/24.0); // UTC -> local tz
 		StelUtils::getDateFromJulianDay(newJd, &year, &month, &day);
 		StelUtils::getTimeFromJulianDay(newJd, &hour, &minute, &second);
-		jd = newJdC;
-		mjd = newJdC-2400000.5;
+		jd = newJd;
+		mjd = newJd-2400000.5;
+
 		pushToWidgets();
 	}
 }

=== modified file 'src/gui/SearchDialog.cpp'
--- src/gui/SearchDialog.cpp	2015-05-09 10:26:41 +0000
+++ src/gui/SearchDialog.cpp	2015-08-03 13:17:13 +0000
@@ -478,7 +478,7 @@
 		case ecliptic:
 		{
 			double ra, dec;
-			StelUtils::eclToEqu(ui->AxisXSpinBox->valueRadians(), ui->AxisYSpinBox->valueRadians(), core->getCurrentPlanet()->getRotObliquity(core->getJDay()), &ra, &dec);
+			StelUtils::eclToEqu(ui->AxisXSpinBox->valueRadians(), ui->AxisYSpinBox->valueRadians(), core->getCurrentPlanet()->getRotObliquity(core->getJDE()), &ra, &dec);
 			StelUtils::spheToRect(ra, dec, pos);
 			pos = core->equinoxEquToJ2000(pos);
 			break;

=== modified file 'src/gui/StelGui.cpp'
--- src/gui/StelGui.cpp	2015-03-09 12:26:02 +0000
+++ src/gui/StelGui.cpp	2015-08-03 13:17:13 +0000
@@ -523,7 +523,7 @@
 		forceRefreshGui();
 	}
 
-	dateTimeDialog->setDateTime(core->getJDay());
+	dateTimeDialog->setDateTime(core->getJD());
 }
 
 #ifndef DISABLE_SCRIPTING

=== modified file 'src/gui/StelGuiItems.cpp'
--- src/gui/StelGuiItems.cpp	2015-08-02 17:12:29 +0000
+++ src/gui/StelGuiItems.cpp	2015-08-03 13:17:13 +0000
@@ -537,56 +537,49 @@
 	updateText(true);
 }
 
+// create text elements and tooltips in bottom toolbar.
 // Make sure to avoid any change if not necessary to avoid triggering useless redraw
 void BottomStelBar::updateText(bool updatePos)
 {
 	StelCore* core = StelApp::getInstance().getCore();
-	double jd = core->getJDay();
-	double deltaT = 0.;
-	double sigma = -1.;
-	QString sigmaInfo = "";	
-	QString validRangeInfo = "";
-	bool displayDeltaT = false;
-	if (core->getCurrentLocation().planetName.contains("Earth"))
-	{
-		deltaT = core->getDeltaT(jd);
-		displayDeltaT = true;		
-		sigma = StelUtils::getDeltaTStandardError(jd);
-		core->getCurrentDeltaTAlgorithmValidRange(jd, &validRangeInfo);
-	}
+	double jd = core->getJD();
+	double deltaT = core->getDeltaT();
+	double sigma = StelUtils::getDeltaTStandardError(jd);
+	QString sigmaInfo = "";
+	QString validRangeMarker = "";
+	core->getCurrentDeltaTAlgorithmValidRangeDescription(jd, &validRangeMarker);
 
 	const StelLocaleMgr& locmgr = StelApp::getInstance().getLocaleMgr();
-	double dt = deltaT/86400.; // A DeltaT correction. Divide DeltaT by 86400 to convert from seconds to days.
-	QString tz = locmgr.getPrintableTimeZoneLocal(jd-dt);
+	QString tz = locmgr.getPrintableTimeZoneLocal(jd);
 	QString newDateInfo = " ";
 	if (getFlagShowTime())
 	{
 		if (getFlagShowTz())
-			newDateInfo = QString("%1   %2 %3").arg(locmgr.getPrintableDateLocal(jd-dt)).arg(locmgr.getPrintableTimeLocal(jd-dt)).arg(tz);
+			newDateInfo = QString("%1   %2 %3").arg(locmgr.getPrintableDateLocal(jd)).arg(locmgr.getPrintableTimeLocal(jd)).arg(tz);
 		else
-			newDateInfo = QString("%1   %2").arg(locmgr.getPrintableDateLocal(jd-dt)).arg(locmgr.getPrintableTimeLocal(jd-dt));
+			newDateInfo = QString("%1   %2").arg(locmgr.getPrintableDateLocal(jd)).arg(locmgr.getPrintableTimeLocal(jd));
 	}
-	QString newDateAppx = QString("JD %1").arg(jd-dt, 0, 'f', 5);
+	QString newDateAppx = QString("JD %1").arg(jd, 0, 'f', 5);
 	if (getFlagTimeJd())
 	{
 		newDateAppx = newDateInfo;
-		newDateInfo = QString("JD %1").arg(jd-dt, 0, 'f', 5);
+		newDateInfo = QString("JD %1").arg(jd, 0, 'f', 5);
 	}
 
 	if (datetime->text()!=newDateInfo)
 	{
 		updatePos = true;		
 		datetime->setText(newDateInfo);
-		if (displayDeltaT && core->getCurrentDeltaTAlgorithm()!=StelCore::WithoutCorrection)
+		if (core->getCurrentDeltaTAlgorithm()!=StelCore::WithoutCorrection)
 		{
 			if (sigma>0)
 				sigmaInfo = QString("; %1(%2T) = %3s").arg(QChar(0x03c3)).arg(QChar(0x0394)).arg(sigma, 3, 'f', 1);
 
 			QString deltaTInfo = "";
 			if (qAbs(deltaT)>60.)
-				deltaTInfo = QString("%1 (%2s)%3").arg(StelUtils::hoursToHmsStr(deltaT/3600.)).arg(deltaT, 5, 'f', 2).arg(validRangeInfo);
+				deltaTInfo = QString("%1 (%2s)%3").arg(StelUtils::hoursToHmsStr(deltaT/3600.)).arg(deltaT, 5, 'f', 2).arg(validRangeMarker);
 			else
-				deltaTInfo = QString("%1s%2").arg(deltaT, 3, 'f', 3).arg(validRangeInfo);
+				deltaTInfo = QString("%1s%2").arg(deltaT, 3, 'f', 3).arg(validRangeMarker);
 
 			datetime->setToolTip(QString("<p style='white-space:pre'>%1T = %2 [n-dot @ -23.8946\"/cy%3%4]<br>%5</p>").arg(QChar(0x0394)).arg(deltaTInfo).arg(QChar(0x00B2)).arg(sigmaInfo).arg(newDateAppx));
 		}
@@ -594,6 +587,7 @@
 			datetime->setToolTip(QString("%1").arg(newDateAppx));
 	}
 
+	// build location tooltip
 	QString newLocation = "";
 	const StelLocation* loc = &core->getCurrentLocation();
 	const StelTranslator& trans = locmgr.getSkyTranslator();
@@ -633,6 +627,8 @@
 	}
 
 	QString str;
+
+	// build fov tooltip
 	QTextStream wos(&str);
 	if (getFlagFovDms())
 	{
@@ -659,6 +655,8 @@
 	}
 
 	str="";
+
+	// build fps tooltip
 	QTextStream wos2(&str);
 	wos2 << qSetRealNumberPrecision(3) << StelApp::getInstance().getFps() << " FPS";
 	if (fps->text()!=str)

=== modified file 'src/gui/dateTimeDialogGui.ui'
--- src/gui/dateTimeDialogGui.ui	2015-02-05 15:36:01 +0000
+++ src/gui/dateTimeDialogGui.ui	2015-08-03 13:17:13 +0000
@@ -557,7 +557,7 @@
      </widget>
      <widget class="QWidget" name="julianDateTab">
       <attribute name="title">
-       <string>Julian Date</string>
+       <string>Julian Day</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_3">
        <property name="leftMargin">
@@ -599,7 +599,7 @@
           <item>
            <widget class="QLabel" name="label_5">
             <property name="toolTip">
-             <string>Julian Date</string>
+             <string>Julian Day</string>
             </property>
             <property name="text">
              <string notr="true">JD:</string>
@@ -664,7 +664,7 @@
           <item>
            <widget class="QLabel" name="label_6">
             <property name="toolTip">
-             <string>Modified Julian Date</string>
+             <string>Modified Julian Day</string>
             </property>
             <property name="text">
              <string notr="true">MJD:</string>

=== modified file 'src/scripting/StelMainScriptAPI.cpp'
--- src/scripting/StelMainScriptAPI.cpp	2015-07-21 20:42:50 +0000
+++ src/scripting/StelMainScriptAPI.cpp	2015-08-03 13:17:13 +0000
@@ -104,17 +104,17 @@
 }
 
 //! Set the current date in Julian Day
-//! @param JD the Julian Date
+//! @param JD the Julian Date (UT)
 void StelMainScriptAPI::setJDay(double JD)
 {
-	StelApp::getInstance().getCore()->setJDay(JD);
+	StelApp::getInstance().getCore()->setJD(JD);
 }
 
 //! Get the current date in Julian Day
-//! @return the Julian Date
+//! @return the Julian Date (UT)
 double StelMainScriptAPI::getJDay() const
 {
-	return StelApp::getInstance().getCore()->getJDay();
+	return StelApp::getInstance().getCore()->getJD();
 }
 
 //! Set the current date in Modified Julian Day
@@ -131,31 +131,42 @@
 	return StelApp::getInstance().getCore()->getMJDay();
 }
 
-void StelMainScriptAPI::setDate(const QString& dt, const QString& spec, const bool &enableDeltaT)
+void StelMainScriptAPI::setDate(const QString& dateStr, const QString& spec, const bool &dateIsDT)
 {
-	bool relativeTime = false;
-	if (dt.startsWith("+") || dt.startsWith("-") || (dt.startsWith("now") && (dt.startsWith("+") || dt.startsWith("-"))))
-		relativeTime = true;
-	double JD = jdFromDateString(dt, spec);
 	StelCore* core = StelApp::getInstance().getCore();
-	if (relativeTime)
+	double JD = jdFromDateString(dateStr, spec);
+	if (dateIsDT)
 	{
-		core->setJDay(JD);
+		qWarning() << "StelMainScriptAPI::setDate() called with final Boolean set to indicate Dynamical Time. This is new in 0.14, make sure you did this intentionally.";
+		qWarning() << "This warning will go away in Stellarium 0.16, please update the script by then to be sure.";
+		core->setJDE(JD);
 	}
 	else
-	{
-		if (enableDeltaT)
-		{
-			// add Delta-T correction for date
-			core->setJDay(JD + core->getDeltaT(JD)/86400);
-		}
-		else
-		{
-			// set date without Delta-T correction
-			// compatible with 0.11
-			core->setJDay(JD);
-		}
-	}
+		core->setJD(JD);
+
+//	bool relativeTime = false;
+//	if (dateStr.startsWith("+") || dateStr.startsWith("-") || (dateStr.startsWith("now") && (dateStr.startsWith("+") || dateStr.startsWith("-"))))
+//		relativeTime = true;
+//	double JD = jdFromDateString(dateStr, spec);
+//	StelCore* core = StelApp::getInstance().getCore();
+//	if (relativeTime)
+//	{
+//		core->setJDay(JD);
+//	}
+//	else
+//	{
+//		if (dateIsDT)
+//		{
+//			// add Delta-T correction for date
+//			core->setJDay(JD + core->getDeltaT(JD)/86400);
+//		}
+//		else
+//		{
+//			// set date without Delta-T correction
+//			// compatible with 0.11
+//			core->setJDay(JD);
+//		}
+//	}
 }
 
 QString StelMainScriptAPI::getDate(const QString& spec)
@@ -168,7 +179,7 @@
 
 QString StelMainScriptAPI::getDeltaT() const
 {
-	return StelUtils::hoursToHmsStr(StelApp::getInstance().getCore()->getDeltaT(getJDay())/3600.);
+	return StelUtils::hoursToHmsStr(StelApp::getInstance().getCore()->getDeltaT()/3600.);
 }
 
 QString StelMainScriptAPI::getDeltaTAlgorithm() const
@@ -691,7 +702,7 @@
 		if (nowRe.capturedTexts().at(1)=="now")
 			jd = StelUtils::getJDFromSystem();
 		else
-			jd = core->getJDay();
+			jd = core->getJD();
 
 		if (nowRe.capturedTexts().at(8) == "sidereal")
 		{

=== modified file 'src/scripting/StelMainScriptAPI.hpp'
--- src/scripting/StelMainScriptAPI.hpp	2015-07-21 20:42:50 +0000
+++ src/scripting/StelMainScriptAPI.hpp	2015-08-03 13:17:13 +0000
@@ -44,22 +44,22 @@
 
 // These functions will be available in scripts
 public slots:
-	//! Set the current date in Julian Day
-	//! @param JD the Julian Date
+	//! Set the current date as Julian Day number
+	//! @param JD the Julian Day number
 	void setJDay(double JD);
-	//! Get the current date in Julian Day
-	//! @return the Julian Date
+	//! Get the current date as Julian Day number
+	//! @return the Julian Day number
 	double getJDay() const;
 
-	//! Set the current date in Modified Julian Day
-	//! @param MJD the Modified Julian Date
+	//! Set the current date as Modified Julian Day
+	//! @param MJD the Modified Julian Day
 	void setMJDay(double MJD);
-	//! Get the current date in Modified Julian Day
-	//! @return the Modified Julian Date
+	//! Get the current date as Modified Julian Day
+	//! @return the Modified Julian Day
 	double getMJDay() const;
 
 	//! set the date in ISO format, e.g. "2008-03-24T13:21:01"
-	//! @param dt the date string to use.  Formats:
+	//! @param dateStr the date string to use.  Formats:
 	//! - ISO, e.g. "2008-03-24T13:21:01"
 	//! - "now" (set sim time to real time)
 	//! - relative, e.g. "+ 4 days", "-2 weeks".  can use these
@@ -71,8 +71,9 @@
 	//! of the unit is 1.  i.e. use "+ 1 days" not "+1 day".
 	//! @note when sidereal time is used, the length of time for
 	//! each unit is dependent on the current planet.  By contrast
-	//! when sidereal timeis not specified (i.e. solar time is used)
+	//! when sidereal time is not specified (i.e. solar time is used)
 	//! the value is conventional - i.e. 1 day means 1 Earth Solar day.
+	// TODO: This calls for implementing "sol" days (planets's solar days)!
 	//! @param spec "local" or "utc" - only has an effect when
 	//! the ISO date type is used. Defaults to "utc".
 	//! @param enableDeltaT is \a true or \a false - enable Delta-T correction or not.
@@ -81,7 +82,11 @@
 	//! or earlier, you should call \b core.setDeltaTAlgorithm("WithoutCorrection");
 	//! before running \b core.setDate(); for disabling DeltaT correction.
 	//! @note starting with version 0.13.2 all relative dates are set without DeltaT correction.
-	void setDate(const QString& dt, const QString& spec="utc", const bool& enableDeltaT=true);
+	//! @note starting with version 0.14.0 the final optional Boolean argument has a different meaning and default!
+	//! @param dateIsTT \a true if the given date is formulated in Dynamical Time, i.e. with DeltaT added.
+	//  GZ JDfix for 0.14: I estimate 99.7% of users will want to set UT-based dates here. We could use an awkward name like dateIsUTbased=true to keep default value true.
+	//void setDate(const QString& dt, const QString& spec="utc", const bool& enableDeltaT=true);
+	void setDate(const QString& dateStr, const QString& spec="utc", const bool& dateIsDT=false);
 
 	//! get the simulation date and time as a string in ISO format,
 	//! e.g. "2008-03-24T13:21:01"