Threaded planet computation (and a few more speedups)

CMakeLists.txt

@@ -1058,6 +1058,11 @@ IF(NOT FROM_CHARS_WORKS)
     ADD_DEFINITIONS(-DUSE_FAST_FLOAT)
 ENDIF()
 
+include("cmake/Check-std_execution.cmake")
+IF(STD_EXECUTION_KNOWN)
+ADD_DEFINITIONS(-DSTD_EXECUTION_KNOWN)
+ENDIF()
+
 ########### Top level include directories ###########
 # This will be used for all compilations in sub-directories
 INCLUDE_DIRECTORIES(

cmake/Check-std_execution.cmake

@@ -0,0 +1,7 @@
+message(STATUS "Checking that std::execution::par is supported by the C++ library")
+try_compile(STD_EXECUTION_KNOWN "${CMAKE_BINARY_DIR}" "${CMAKE_CURRENT_LIST_DIR}/check-std_execution.cpp")
+if(STD_EXECUTION_KNOWN)
+	message(STATUS "Checking that std::execution::par is supported by the C++ library - yes")
+else()
+	message(STATUS "Checking that std::execution::par is supported by the C++ library - NO")
+endif()

cmake/check-std_execution.cpp

@@ -0,0 +1,13 @@
+#include <array>
+#include <execution>
+#include <numeric>
+
+
+const std::array<double, 4>a = {{0., 1., 2., 3.}};
+
+int main()
+{
+	double res = std::reduce(std::execution::par,
+	             a.begin(), a.end(), 0.0, std::plus<>());
+	return 0;
+}

guide/ch_interface.tex

@@ -391,6 +391,20 @@ \subsection{The Tools Tab}
 from touch-enabled devices like smartphones. 
 \end{description}
 
+\paragraph{Multithreading} \label{sec:gui:configuration:tools:threads} 
+For every frame, the positions of all planets and minor bodies of the Solar system are computed. 
+Most of the other time between frame updates is needed for the actual frame drawing, 
+and waiting for the next frame cycle if you have deliberately set a low frame rate (useful to conserve energy; see below). 
+If you have many thousands of solar system objects and a moderately new computer, 
+you may feel that Stellarium becomes slow (few frames/second) but see that mostly only one core of your CPU seems to be busy.  
+You can try\newFeature{24.3} to distribute the computation of solar system bodies to more CPU cores. 
+But take note, thread synchronization (combining all results ahead of drawing) takes its time, 
+so it pays off only when your solar system is really large. 
+With more than 1000 objects, we recommend starting with 1 additional thread. 
+Even with 25.000 objects, assigning more than 4 additional threads on a 20-core CPU does not show any further gain. 
+Frame drawing is still performed by the main thread, and too many objects still slow down the program. 
+Just try out what works best on your system.
+
 \paragraph{Framerate intent} \label{sec:gui:configuration:tools:fps} The pace of screen updates (frames per second, FPS) depends on several factors: 
 CPU speed, graphics card speed, screen size, number of displayed objects and grids, etc. 
 As is common for interactive programs, the main program thread runs on a single core also on a multicore system. 
@@ -679,6 +693,18 @@ \subsection{The Solar System Objects (SSO) Tab}
     in the sky, which can be nice for didactic purposes or demonstrations.
   \item[Planets] will increase the apparent size of major planets.
   \end{description}
+\item[Mark minor bodies] Show\newFeature{24.3} a little circle at the location of every minor body (comet,
+  asteroid, \ldots), down to the configured visual magnitude.
+  The marks are shown regardless of sky brightness, even in daytime. Also, in this mode, markers for objects 
+  with highly outdated orbital elements are still plotted (see \ref{sec:plugins:SolarSystemEditor} 
+  and Appendix~\ref{sec:ssystem.ini:minor}). 
+  This is useful to show the distribution of asteroids and comets on the sky, 
+  or especially when viewed from the Solar System Observer (see \ref{sec:gui:location:observers}). 
+
+  From the ``Observer'' viewpoints, the visual magnitude for minor bodies is computed as seen from the Sun,
+  so that objects in inferior conjunction ae not dimmed down and filtered away by effects of phase angle, 
+  and comet tails are better visible. 
+
 \item[Show orbits] adds a rendition of the orbit or trajectory of an SSO. 
 For efficiency, orbits are not displayed when the object is not inside the screen, 
 unless you set the ``permanently'' option. You can further fine-tune the selection 

plugins/NavStars/src/gui/NavStarsWindow.cpp

@@ -199,7 +199,8 @@ void NavStarsWindow::populateToday()
 	astronomicalTwilightDuration = StelUtils::hoursToHmsStr(duration, true);
 
 	// fill the data
-	ui->labelToday->setText(localeMgr->getPrintableDateLocal(core->getJD()));
+	const double JD=core->getJD();
+	ui->labelToday->setText(localeMgr->getPrintableDateLocal(JD, core->getUTCOffset(JD)));
 	ui->labelDayBegin->setText(dayBegin);
 	ui->labelDayEnd->setText(dayEnd);
 	ui->labelDayDuration->setText(dayDuration);

plugins/Novae/src/Nova.cpp

@@ -22,7 +22,7 @@
 #include "StelCore.hpp"
 #include "StelUtils.hpp"
 #include "StelTranslator.hpp"
-#include "StelModuleMgr.hpp"
+//#include "StelModuleMgr.hpp"
 #include "StelSkyDrawer.hpp"
 #include "StelLocaleMgr.hpp"
 #include "StelPainter.hpp"
@@ -130,9 +130,9 @@ QString Nova::getDesignation() const
 	return designation;
 }
 
-QString Nova::getMaxBrightnessDate(const double JD) const
+QString Nova::getMaxBrightnessDate(const StelCore *core, const double JD) const
 {
-	return StelApp::getInstance().getLocaleMgr().getPrintableDateLocal(JD);
+	return StelApp::getInstance().getLocaleMgr().getPrintableDateLocal(JD, core->getUTCOffset(JD));
 }
 
 QString Nova::getInfoString(const StelCore* core, const InfoStringGroup& flags) const
@@ -157,7 +157,7 @@ QString Nova::getInfoString(const StelCore* core, const InfoStringGroup& flags)
 
 	if (flags&Extra)
 	{
-		oss << QString("%1: %2").arg(q_("Maximum brightness"), getMaxBrightnessDate(peakJD)) << "<br />";
+		oss << QString("%1: %2").arg(q_("Maximum brightness"), getMaxBrightnessDate(core, peakJD)) << "<br />";
 		if (distance>0)
 		{
 			//TRANSLATORS: Unit of measure for distance - Light Years

plugins/Novae/src/Nova.hpp

@@ -118,7 +118,7 @@ class Nova : public StelObject
 
 	static bool syncShowLabels;
 
-	QString getMaxBrightnessDate(const double JD) const;
+	QString getMaxBrightnessDate(const StelCore *core, const double JD) const;
 };
 
 #endif // NOVA_HPP

plugins/Observability/src/Observability.cpp

@@ -766,12 +766,13 @@ void Observability::updateSunData(StelCore* core)
 	nDays = (year==sameYear)?366:365;
 
 // Compute Earth's position throughout the year:
+	const StelObserver *obs=core->getCurrentObserver();
 	Vec3d pos, sunPos;
 	for (int i=0; i<nDays; i++)
 	{
 		yearJD[i].first = Jan1stJD + i;
 		yearJD[i].second = yearJD[i].first+core->computeDeltaT(yearJD[i].first)/86400.0;
-		myEarth->computePosition(yearJD[i].second, Vec3d(0.));
+		myEarth->computePosition(obs, yearJD[i].second, Vec3d(0.));
 		myEarth->computeTransMatrix(yearJD[i].first, yearJD[i].second);
 		pos = myEarth->getHeliocentricEclipticPos();
 		sunPos = core->j2000ToEquinoxEqu((StelCore::matVsop87ToJ2000)*(-pos), StelCore::RefractionOff);
@@ -780,7 +781,7 @@ void Observability::updateSunData(StelCore* core)
 	}
 
 //Return the Earth to its current time:
-	myEarth->computePosition(myJD.second, Vec3d(0.));
+	myEarth->computePosition(obs, myJD.second, Vec3d(0.));
 	myEarth->computeTransMatrix(myJD.first, myJD.second);
 }
 ///////////////////////////////////////////////////
@@ -989,16 +990,17 @@ void Observability::getSunMoonCoords(StelCore *core, QPair<double, double> JD,
 				     double &eclLon, bool getBack)
                                      //, Vec3d &AltAzVector)
 {
+	const StelObserver *obs=core->getCurrentObserver();
 	if (getBack) // Return the Moon and Earth to their current position:
 	{
-		myEarth->computePosition(JD.second, Vec3d(0.));
+		myEarth->computePosition(obs, JD.second, Vec3d(0.));
 		myEarth->computeTransMatrix(JD.first, JD.second);
-		myMoon->computePosition(JD.second, Vec3d(0.));
+		myMoon->computePosition(obs, JD.second, Vec3d(0.));
 		myMoon->computeTransMatrix(JD.first, JD.second);
 	}
 	else // Compute coordinates:
 	{
-		myEarth->computePosition(JD.second, Vec3d(0.));
+		myEarth->computePosition(obs, JD.second, Vec3d(0.));
 		myEarth->computeTransMatrix(JD.first, JD.second);
 		Vec3d earthPos = myEarth->getHeliocentricEclipticPos();
 		double curSidT;
@@ -1011,7 +1013,7 @@ void Observability::getSunMoonCoords(StelCore *core, QPair<double, double> JD,
 		curSidT = myEarth->getSiderealTime(JD.first, JD.second)/Rad2Deg;
 		RotObserver = (Mat4d::zrotation(curSidT))*ObserverLoc;
 		LocTrans = (StelCore::matVsop87ToJ2000)*(Mat4d::translation(-earthPos));
-		myMoon->computePosition(JD.second, Vec3d(0.));
+		myMoon->computePosition(obs, JD.second, Vec3d(0.));
 		myMoon->computeTransMatrix(JD.first, JD.second);
 		Vec3d moonPos = myMoon->getHeliocentricEclipticPos();
 		sunPos = (core->j2000ToEquinoxEqu(LocTrans*moonPos, StelCore::RefractionOff))-RotObserver;
@@ -1028,16 +1030,17 @@ void Observability::getSunMoonCoords(StelCore *core, QPair<double, double> JD,
 // getBack controls whether Earth and Moon must be returned to their original positions after computation.
 void Observability::getMoonDistance(StelCore *core, QPair<double, double> JD, double &distance, bool getBack)
 {
+	const StelObserver *obs=core->getCurrentObserver();
 	if (getBack) // Return the Moon and Earth to their current position:
 	{
-		myEarth->computePosition(JD.second, Vec3d(0.));
+		myEarth->computePosition(obs, JD.second, Vec3d(0.));
 		myEarth->computeTransMatrix(JD.first, JD.second);
-		myMoon->computePosition(JD.second, Vec3d(0.));
+		myMoon->computePosition(obs, JD.second, Vec3d(0.));
 		myMoon->computeTransMatrix(JD.first, JD.second);
 	}
 	else
 	{	// Compute coordinates:
-		myEarth->computePosition(JD.second, Vec3d(0.));
+		myEarth->computePosition(obs, JD.second, Vec3d(0.));
 		myEarth->computeTransMatrix(JD.first, JD.second);
 		Vec3d earthPos = myEarth->getHeliocentricEclipticPos();
 //		double curSidT;
@@ -1050,7 +1053,7 @@ void Observability::getMoonDistance(StelCore *core, QPair<double, double> JD, do
 //		curSidT = myEarth->getSiderealTime(JD)/Rad2Deg;
 //		RotObserver = (Mat4d::zrotation(curSidT))*ObserverLoc;
 		LocTrans = (StelCore::matVsop87ToJ2000)*(Mat4d::translation(-earthPos));
-		myMoon->computePosition(JD.second, Vec3d(0.));
+		myMoon->computePosition(obs, JD.second, Vec3d(0.));
 		myMoon->computeTransMatrix(JD.first, JD.second);
 		Pos1 = myMoon->getHeliocentricEclipticPos();
 		Pos2 = core->j2000ToEquinoxEqu(LocTrans*Pos1, StelCore::RefractionOff); //-RotObserver;
@@ -1066,20 +1069,21 @@ void Observability::getMoonDistance(StelCore *core, QPair<double, double> JD, do
 // Get the Coords of a planet:
 void Observability::getPlanetCoords(StelCore *core, QPair<double, double> JD, double &RA, double &Dec, bool getBack)
 {
+	const StelObserver *obs=core->getCurrentObserver();
 	if (getBack)
 	{
 	// Return the planet to its current time:
-		myPlanet->computePosition(JD.second, Vec3d(0.));
+		myPlanet->computePosition(obs, JD.second, Vec3d(0.));
 		myPlanet->computeTransMatrix(JD.first, JD.second);
-		myEarth->computePosition(JD.second, Vec3d(0.));
+		myEarth->computePosition(obs, JD.second, Vec3d(0.));
 		myEarth->computeTransMatrix(JD.first, JD.second);
 	} else
 	{
 	// Compute planet's position:
-		myPlanet->computePosition(JD.second, Vec3d(0.));
+		myPlanet->computePosition(obs, JD.second, Vec3d(0.));
 		myPlanet->computeTransMatrix(JD.first, JD.second);
 		Pos1 = myPlanet->getHeliocentricEclipticPos();
-		myEarth->computePosition(JD.second, Vec3d(0.));
+		myEarth->computePosition(obs, JD.second, Vec3d(0.));
 		myEarth->computeTransMatrix(JD.first, JD.second);
 		Pos2 = myEarth->getHeliocentricEclipticPos();
 		LocTrans = (StelCore::matVsop87ToJ2000)*(Mat4d::translation(-Pos2));
@@ -1102,14 +1106,15 @@ bool Observability::calculateSolarSystemEvents(StelCore* core, int bodyType)
 	hHoriz = calculateHourAngle(mylat, refractedHorizonAlt, selDec);
 	bool raises = hHoriz > 0.0;
 
+	const StelObserver *obs=core->getCurrentObserver();
 
 // 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.first-lastJDMoon)>StelCore::JD_SECOND || lastType!=bodyType || souChanged)
 	{
 		lastType = bodyType;
 
-		myEarth->computePosition(myJD.second, Vec3d(0.));
+		myEarth->computePosition(obs, myJD.second, Vec3d(0.));
 		myEarth->computeTransMatrix(myJD.first, myJD.second);
 		Vec3d earthPos = myEarth->getHeliocentricEclipticPos();
 
@@ -1122,14 +1127,14 @@ bool Observability::calculateSolarSystemEvents(StelCore* core, int bodyType)
 			curSidT = myEarth->getSiderealTime(myJD.first, myJD.second)/Rad2Deg;
 			RotObserver = (Mat4d::zrotation(curSidT))*ObserverLoc;
 			LocTrans = (StelCore::matVsop87ToJ2000)*(Mat4d::translation(-earthPos));
-			myMoon->computePosition(myJD.second, Vec3d(0.));
+			myMoon->computePosition(obs, myJD.second, Vec3d(0.));
 			myMoon->computeTransMatrix(myJD.first, myJD.second);
 			Pos1 = myMoon->getHeliocentricEclipticPos();
 			Pos2 = (core->j2000ToEquinoxEqu(LocTrans*Pos1, StelCore::RefractionOff))-RotObserver;
 		}
 		else // Planet position
 		{
-			myPlanet->computePosition(myJD.second, Vec3d(0.));
+			myPlanet->computePosition(obs, myJD.second, Vec3d(0.));
 			myPlanet->computeTransMatrix(myJD.first, myJD.second);
 			Pos1 = myPlanet->getHeliocentricEclipticPos();
 			LocTrans = (StelCore::matVsop87ToJ2000)*(Mat4d::translation(-earthPos));
@@ -1901,20 +1906,20 @@ QString Observability::getReportAsJson() {
     QString report = QString("{ ");
 	if ((isMoon(objectSelection) && show_FullMoon) || (!isSun(objectSelection) && !isMoon(objectSelection) && shouldShowYear()))
 	{
-        report += QString("\"%1\": \"%2\", ").arg("title").arg(msgThisYear);
+	report += QString("\"title\": \"%1\", ").arg(msgThisYear);
 		if (show_Best_Night || show_FullMoon)
 		{
-            report += QString("\"%1\": \"%2\", ").arg("bestNight").arg(lineBestNight);
+	    report += QString("\"bestNight\": \"%1\", ").arg(lineBestNight);
 		}
 		if (show_Good_Nights)
 		{
-            report += QString("\"%1\": \"%2\", ").arg("observableRange").arg(lineObservableRange);
+	    report += QString("\"observableRange\": \"%1\", ").arg(lineObservableRange);
 		}
 		if (show_AcroCos)
 		{
-            report += QString("\"%1\": \"%2\", ").arg("acronychal").arg(lineAcro);
-            report += QString("\"%1\": \"%2\", ").arg("cosmic").arg(lineCosm);
-            report += QString("\"%1\": \"%2\" ").arg("heliacal").arg(lineHeli);
+	    report += QString("\"acronychal\": \"%1\", ").arg(lineAcro);
+	    report += QString("\"cosmic\": \"%1\", ").arg(lineCosm);
+	    report += QString("\"heliacal\": \"%1\" ").arg(lineHeli);
 		}
 	}
     report += QString("}");

plugins/RemoteControl/src/MainService.cpp

@@ -140,7 +140,7 @@ void MainService::get(const QByteArray& operation, const APIParameters &paramete
 			QString localIso = StelUtils::julianDayToISO8601String(jday+gmtShift,true);
 
 			//time zone string
-			QString timeZone = localeMgr->getPrintableTimeZoneLocal(jday);
+			QString timeZone = localeMgr->getPrintableTimeZoneLocal(jday, core->getUTCOffset(jday));
 
 			QJsonObject obj2;
 			obj2.insert("jday",jday);

plugins/Supernovae/src/Supernova.cpp

@@ -109,9 +109,9 @@ QString Supernova::getEnglishName(void) const
 	return name;
 }
 
-QString Supernova::getMaxBrightnessDate(const double JD) const
+QString Supernova::getMaxBrightnessDate(const StelCore *core, const double JD) const
 {
-	return StelApp::getInstance().getLocaleMgr().getPrintableDateLocal(JD);
+	return StelApp::getInstance().getLocaleMgr().getPrintableDateLocal(JD, core->getUTCOffset(JD));
 }
 
 QString Supernova::getMagnitudeInfoString(const StelCore *core, const InfoStringGroup& flags, const int decimals) const
@@ -152,7 +152,7 @@ QString Supernova::getInfoString(const StelCore* core, const InfoStringGroup& fl
 	if (flags&Extra)
 	{
 		oss << QString("%1: %2").arg(q_("Type of supernova"), sntype) << "<br />";
-		oss << QString("%1: %2").arg(q_("Maximum brightness"), getMaxBrightnessDate(peakJD)) << "<br />";
+		oss << QString("%1: %2").arg(q_("Maximum brightness"), getMaxBrightnessDate(core, peakJD)) << "<br />";
 		if (distance>0)
 		{
 			//TRANSLATORS: Unit of measure for distance - Light Years

plugins/Supernovae/src/Supernova.hpp

@@ -119,7 +119,7 @@ class Supernova : public StelObject
 
 	static bool syncShowLabels;
 
-	QString getMaxBrightnessDate(const double JD) const;
+	QString getMaxBrightnessDate(const StelCore *core, const double JD) const;
 };
 
 #endif // SUPERNOVA_HPP

plugins/TextUserInterface/src/TextUserInterface.cpp

@@ -661,9 +661,10 @@ void TextUserInterface::draw(StelCore* core)
 	{
 		double jd = core->getJD();
 		int text_x = x + xVc*2/3, text_y = y + pixOffset;
+		const double utcOffsetHrs=core->getUTCOffset(jd);
 
-		QString newDate = StelApp::getInstance().getLocaleMgr().getPrintableDateLocal(jd) + "   "
-                       +StelApp::getInstance().getLocaleMgr().getPrintableTimeLocal(jd);
+		QString newDate = StelApp::getInstance().getLocaleMgr().getPrintableDateLocal(jd, utcOffsetHrs) + "   "
+		       +StelApp::getInstance().getLocaleMgr().getPrintableTimeLocal(jd, utcOffsetHrs);
 
 		if (fovMaskDisk) {
 			text_x = xVc + fovOffsetY - pixOffset;

src/core/SolarEclipseComputer.cpp

@@ -2005,21 +2005,21 @@ void SolarEclipseComputer::generateKML(const EclipseMapData& data, const QString
 	stream << "<PolyStyle>\n<color>" << toKMLColorString(eclipseLimitsColor) << "</color>\n</PolyStyle>\n</Style>\n";
 
 	{
-		const auto timeStr = localeMgr->getPrintableTimeLocal(data.greatestEclipse.JD);
+		const auto timeStr = localeMgr->getPrintableTimeLocal(data.greatestEclipse.JD, core->getUTCOffset(data.greatestEclipse.JD));
 		stream << "<Placemark>\n<name>"+q_("Greatest eclipse")+" ("+timeStr+")</name>\n<Point>\n<coordinates>";
 		stream << data.greatestEclipse.longitude << "," << data.greatestEclipse.latitude << ",0.0\n";
 		stream << "</coordinates>\n</Point>\n</Placemark>\n";
 	}
 
 	{
-		const auto timeStr = localeMgr->getPrintableTimeLocal(data.firstContactWithEarth.JD);
+		const auto timeStr = localeMgr->getPrintableTimeLocal(data.firstContactWithEarth.JD, core->getUTCOffset(data.firstContactWithEarth.JD));
 		stream << "<Placemark>\n<name>"+q_("First contact with Earth")+" ("+timeStr+")</name>\n<Point>\n<coordinates>";
 		stream << data.firstContactWithEarth.longitude << "," << data.firstContactWithEarth.latitude << ",0.0\n";
 		stream << "</coordinates>\n</Point>\n</Placemark>\n";
 	}
 
 	{
-		const auto timeStr = localeMgr->getPrintableTimeLocal(data.lastContactWithEarth.JD);
+		const auto timeStr = localeMgr->getPrintableTimeLocal(data.lastContactWithEarth.JD, core->getUTCOffset(data.lastContactWithEarth.JD));
 		stream << "<Placemark>\n<name>"+q_("Last contact with Earth")+" ("+timeStr+")</name>\n<Point>\n<coordinates>";
 		stream << data.lastContactWithEarth.longitude << "," << data.lastContactWithEarth.latitude << ",0.0\n";
 		stream << "</coordinates>\n</Point>\n</Placemark>\n";
@@ -2102,15 +2102,15 @@ void SolarEclipseComputer::generateKML(const EclipseMapData& data, const QString
 
 	if(data.centralEclipseStart.JD > 0)
 	{
-		const auto timeStr = localeMgr->getPrintableTimeLocal(data.centralEclipseStart.JD);
+		const auto timeStr = localeMgr->getPrintableTimeLocal(data.centralEclipseStart.JD, core->getUTCOffset(data.centralEclipseStart.JD));
 		stream << "<Placemark>\n<name>"+q_("Central eclipse begins")+" ("+timeStr+")</name>\n<Point>\n<coordinates>";
 		stream << data.centralEclipseStart.longitude << "," << data.centralEclipseStart.latitude << ",0.0\n";
 		stream << "</coordinates>\n</Point>\n</Placemark>\n";
 	}
 
 	if(data.centralEclipseEnd.JD > 0)
 	{
-		const auto timeStr = localeMgr->getPrintableTimeLocal(data.centralEclipseEnd.JD);
+		const auto timeStr = localeMgr->getPrintableTimeLocal(data.centralEclipseEnd.JD, core->getUTCOffset(data.centralEclipseEnd.JD));
 		stream << "<Placemark>\n<name>"+q_("Central eclipse ends")+" ("+timeStr+")</name>\n<Point>\n<coordinates>";
 		stream << data.centralEclipseEnd.longitude << "," << data.centralEclipseEnd.latitude << ",0.0\n";
 		stream << "</coordinates>\n</Point>\n</Placemark>\n";
@@ -2127,7 +2127,7 @@ void SolarEclipseComputer::generateKML(const EclipseMapData& data, const QString
 
 	for(const auto& outline : data.umbraOutlines)
 	{
-		const auto timeStr = localeMgr->getPrintableTimeLocal(outline.JD);
+		const auto timeStr = localeMgr->getPrintableTimeLocal(outline.JD, core->getUTCOffset(outline.JD));
 		startLinePlaceMark(timeStr, outline.eclipseType);
 		stream << "<tessellate>1</tessellate>\n<altitudeMode>absoluto</altitudeMode>\n<coordinates>\n";
 		for(const auto& p : outline.curve)