Merge lp:~alexwolf/stellarium/apparent-magnitude-algorithm into lp:stellarium

[Alexander Wolf]

This branch extends customization for computation of apparent magnitudes.

I introduced the new option in config.ini "astro/apparent_magnitude_algorithm", which gave users possibility to setting the algorithm for computation of apparent magnitudes for planets in case observer on the Earth.

Possible values for it:
* Planesas (algorithm provided by Pere Planesas (Observatorio Astronomico Nacional))
* Mueller (G. Mueller, based on visual observations 1877-91. [Expl.Suppl.1961])
* Harris (Astronomical Almanac 1984 and later. These give V (instrumental) magnitudes)

I activated Harris's algorithm by default because users asks about "wrong magnitudes for planets", plus all modern astronomical almanacs and websites like JPL's HORIZONS and IMCCE uses this algorithm by default.

I don't added new option to GUI and I think it's shouldn't be added because GUI of the Stellarium are bloated already and this option is proposed for advanced users, who can yourself edit config.ini and know what they are doing.

[gzotti (georg-zotti)]

In principle the idea is very good, given that historical research from early 20th century was based on Mueller, and many people nowadays seem to prefer comparing instrumental magnitudes. I'd lke to know Planesa's original sources, was that some original contribution to Stellarium? (Fabien?)

However, currently it seems to me this is a property of each planet, which seems confusing. I assume users will want a global algorithm setting for all planets. It should either go into SolarSystem or be a static property of the Planet class. There is also a small typo, see below (lowercasing - ah, it's auto-corrected ...).

There could be a selector combo in the Config/Information panel:
Planesas (Stellarium original)
Mueller (visual mag, [Expl.Suppl. 1961])
Harris (V mag [Astron. Almanach 1984])

with details in the README. But I don't insist on that.

review: Needs Fixing

[Alexander Wolf (alexwolf)]

> In principle the idea is very good, given that historical research from early
> 20th century was based on Mueller, and many people nowadays seem to prefer
> comparing instrumental magnitudes. I'd lke to know Planesa's original sources,
> was that some original contribution to Stellarium? (Fabien?)

Sorry, I don't have Planesas original sources (this algorithm was in the code and I just uncommented it).

> However, currently it seems to me this is a property of each planet, which
> seems confusing.

Yes, but I don't know how to avoid crash without applied of this property for all planets.

> I assume users will want a global algorithm setting for all planets.

Huh? It's problematic, because we don't have empirical algorithms for each other planets. Or I just wrongly understood you?

> It should either go into SolarSystem or be a static property of the
> Planet class.

Are you mean the line 121 in Planet.cpp?

> There could be a selector combo in the Config/Information panel:
> Planesas (Stellarium original)
> Mueller (visual mag, [Expl.Suppl. 1961])
> Harris (V mag [Astron. Almanach 1984])
>
> with details in the README. But I don't insist on that.

I'm agree with proposal for README (who read it - maybe we should add it into Help?). But I disagree with proposal for GUI because this feature in really required for little group of the advanced peoples, who make research in archaeoastronomy (or history of astronomy). I hope those peoples can change settings without GUI and we can use the simple GUI yet.

[gzotti (georg-zotti)]

> Planesas
I think Fabien may know more on this history. Private communication on known sources (which?), original work, or where is this from?

> Are you mean the line 121 in Planet.cpp?
Ah sorry, I had overlooked this. Yes, then it's fine for me.

At least the wiki manual must be updated to notify users of the possibility to change values, and of possible values for this setting.

review: Approve

[lp:~alexwolf/stellarium/apparent-magnitude-algorithm]

7113. By Alexander Wolf on 2014-11-01

a tiny fixation

=== modified file 'src/core/modules/Planet.cpp'
--- src/core/modules/Planet.cpp	2014-10-27 16:19:19 +0000
+++ src/core/modules/Planet.cpp	2014-11-01 17:59:05 +0000
@@ -55,6 +55,9 @@
 Planet::RingPlanetShaderVars Planet::ringPlanetShaderVars;
 QOpenGLShaderProgram* Planet::moonShaderProgram=NULL;
 Planet::MoonShaderVars Planet::moonShaderVars;
+
+QMap<Planet::PlanetType, QString> Planet::pTypeMap;
+QMap<Planet::ApparentMagnitudeAlgorithm, QString> Planet::vMagAlgorithmMap;
 	
 Planet::Planet(const QString& englishName,
 	       int flagLighting,
@@ -101,9 +104,10 @@
 
 	// Initialize pType with the key found in pTypeMap, or mark planet type as undefined.
 	// The latter condition should obviously never happen.
-	pType=pTypeMap.key(pTypeStr, Planet::isUNDEFINED);
+	pType = pTypeMap.key(pTypeStr, Planet::isUNDEFINED);
+	vMagAlgorithm = Planet::UndefinedAlgorithm;
 
-	eclipticPos=Vec3d(0.,0.,0.);
+	eclipticPos = Vec3d(0.,0.,0.);
 	rotLocalToParent = Mat4d::identity();
 	texMap = StelApp::getInstance().getTextureManager().createTextureThread(StelFileMgr::getInstallationDir()+"/textures/"+texMapName, StelTexture::StelTextureParams(true, GL_LINEAR, GL_REPEAT));
 	normalMap = StelApp::getInstance().getTextureManager().createTextureThread(StelFileMgr::getInstallationDir()+"/textures/"+normalMapName, StelTexture::StelTextureParams(true, GL_LINEAR, GL_REPEAT));
@@ -116,8 +120,6 @@
 	flagLabels = true;
 }
 
-QMap<Planet::PlanetType, QString> Planet::pTypeMap;
-
 // called in SolarSystem::init() before first planet is created. Loads pTypeMap.
 void Planet::init()
 {
@@ -133,7 +135,17 @@
 	pTypeMap.insert(Planet::isAsteroid, "asteroid");
 	pTypeMap.insert(Planet::isPlutoid,  "plutoid");
 	pTypeMap.insert(Planet::isComet,    "comet");
-	pTypeMap.insert(Planet::isUNDEFINED, "UNDEFINED"); // something must be broken before we ever see this!
+	pTypeMap.insert(Planet::isUNDEFINED,"UNDEFINED"); // something must be broken before we ever see this!
+
+	if (vMagAlgorithmMap.count() > 0)
+	{
+		qDebug() << "Planet::init(): Non-empty static map. This is a programming error, but we can fix that.";
+		vMagAlgorithmMap.clear();
+	}
+	vMagAlgorithmMap.insert(Planet::Planesas,	"planesas");
+	vMagAlgorithmMap.insert(Planet::Mueller,	"mueller");
+	vMagAlgorithmMap.insert(Planet::Harris,		"harris");
+	vMagAlgorithmMap.insert(Planet::UndefinedAlgorithm, "");
 }
 
 Planet::~Planet()
@@ -760,108 +772,135 @@
 	{
 		const double phaseDeg=phase*180./M_PI;
 		const double d = 5. * log10(sqrt(observerPlanetRq*planetRq));
-		//double f1 = phaseDeg/100.;
 
-		/*
-		// Algorithm provided by Pere Planesas (Observatorio Astronomico Nacional)
-		if (englishName=="Mercury")
-		{
-			if ( phaseDeg > 150. ) f1 = 1.5;
-			return -0.36 + d + 3.8*f1 - 2.73*f1*f1 + 2*f1*f1*f1;
-		}
-		if (englishName=="Venus")
-			return -4.29 + d + 0.09*f1 + 2.39*f1*f1 - 0.65*f1*f1*f1;
-		if (englishName=="Mars")
-			return -1.52 + d + 0.016*phaseDeg;
-		if (englishName=="Jupiter")
-			return -9.25 + d + 0.005*phaseDeg;
-		if (englishName=="Saturn")
-		{
-			// TODO re-add rings computation
-			// double rings = -2.6*sinx + 1.25*sinx*sinx;
-			return -8.88 + d + 0.044*phaseDeg;// + rings;
-		}
-		if (englishName=="Uranus")
-			return -7.19 + d + 0.0028*phaseDeg;
-		if (englishName=="Neptune")
-			return -6.87 + d;
-		if (englishName=="Pluto")
-			return -1.01 + d + 0.041*phaseDeg;
-		*/
 		// GZ: I prefer the values given by Meeus, Astronomical Algorithms (1992).
 		// There are two solutions:
 		// (1) G. Mueller, based on visual observations 1877-91. [Expl.Suppl.1961]
 		// (2) Astronomical Almanac 1984 and later. These give V (instrumental) magnitudes.
 		// The structure is almost identical, just the numbers are different!
 		// I activate (1) for now, because we want to simulate the eye's impression. (Esp. Venus!)
-		// (1)
-		if (englishName=="Mercury")
-		    {
-			double ph50=phaseDeg-50.0;
-			return 1.16 + d + 0.02838*ph50 + 0.0001023*ph50*ph50;
-		    }
-		if (englishName=="Venus")
-			return -4.0 + d + 0.01322*phaseDeg + 0.0000004247*phaseDeg*phaseDeg*phaseDeg;
-		if (englishName=="Mars")
-			return -1.3 + d + 0.01486*phaseDeg;
-		if (englishName=="Jupiter")
-			return -8.93 + d;
-		if (englishName=="Saturn")
-		{
-			// add rings computation
-			// GZ: implemented from Meeus, Astr.Alg.1992
-			const double jd=core->getJDay();
-			const double T=(jd-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);
-			const Vec3d saturnEarth=getHeliocentricEclipticPos() - ssystem->getEarth()->getHeliocentricEclipticPos();
-			double lambda=atan2(saturnEarth[1], saturnEarth[0]);
-			double beta=atan2(saturnEarth[2], sqrt(saturnEarth[0]*saturnEarth[0]+saturnEarth[1]*saturnEarth[1]));
-			const double sinB=sin(i)*cos(beta)*sin(lambda-Omega)-cos(i)*sin(beta);
-			double rings = -2.6*fabs(sinB) + 1.25*sinB*sinB; // sinx=sinB, saturnicentric latitude of earth. longish, see Meeus.
-			return -8.68 + d + 0.044*phaseDeg + rings;
-		}
-		if (englishName=="Uranus")
-			return -6.85 + d;
-		if (englishName=="Neptune")
-			return -7.05 + d;
-		if (englishName=="Pluto")
-			return -1.0 + d;
-		/*
-		// (2)
-		if (englishName=="Mercury")
-			return 0.42 + d + .038*phaseDeg - 0.000273*phaseDeg*phaseDeg + 0.000002*phaseDeg*phaseDeg*phaseDeg;
-		if (englishName=="Venus")
-			return -4.40 + d + 0.0009*phaseDeg + 0.000239*phaseDeg*phaseDeg - 0.00000065*phaseDeg*phaseDeg*phaseDeg;
-		if (englishName=="Mars")
-			return -1.52 + d + 0.016*phaseDeg;
-		if (englishName=="Jupiter")
-			return -9.40 + d + 0.005*phaseDeg;
-		if (englishName=="Saturn")
-		{
-			// add rings computation
-			// GZ: implemented from Meeus, Astr.Alg.1992
-			const double jd=core->getJDay();
-			const double T=(jd-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);
-			const Vec3d saturnEarth=getHeliocentricEclipticPos() - ssystem->getEarth()->getHeliocentricEclipticPos();
-			double lambda=atan2(saturnEarth[1], saturnEarth[0]);
-			double beta=atan2(saturnEarth[2], sqrt(saturnEarth[0]*saturnEarth[0]+saturnEarth[1]*saturnEarth[1]));
-			const double sinB=sin(i)*cos(beta)*sin(lambda-Omega)-cos(i)*sin(beta);
-			double rings = -2.6*fabs(sinB) + 1.25*sinB*sinB; // sinx=sinB, saturnicentric latitude of earth. longish, see Meeus.
-			return -8.88 + d + 0.044*phaseDeg + rings;
-		}
-		if (englishName=="Uranus")
-			return -7.19f + d;
-		if (englishName=="Neptune")
-			return -6.87f + d;
-		if (englishName=="Pluto")
-			return -1.00f + d;
-	*/
-	// TODO: decide which set of formulae is best?
+		// AW: (2) activated by default
+
+		switch (core->getCurrentPlanet()->getApparentMagnitudeAlgorithm())
+		{
+			case Planesas:
+			{
+				// Algorithm provided by Pere Planesas (Observatorio Astronomico Nacional)
+				double f1 = phaseDeg/100.;
+
+				if (englishName=="Mercury")
+				{
+					if ( phaseDeg > 150. ) f1 = 1.5;
+					return -0.36 + d + 3.8*f1 - 2.73*f1*f1 + 2*f1*f1*f1;
+				}
+				if (englishName=="Venus")
+					return -4.29 + d + 0.09*f1 + 2.39*f1*f1 - 0.65*f1*f1*f1;
+				if (englishName=="Mars")
+					return -1.52 + d + 0.016*phaseDeg;
+				if (englishName=="Jupiter")
+					return -9.25 + d + 0.005*phaseDeg;
+				if (englishName=="Saturn")
+				{
+					// add rings computation
+					// implemented from Meeus, Astr.Alg.1992
+					const double jd=core->getJDay();
+					const double T=(jd-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);
+					const Vec3d saturnEarth=getHeliocentricEclipticPos() - ssystem->getEarth()->getHeliocentricEclipticPos();
+					double lambda=atan2(saturnEarth[1], saturnEarth[0]);
+					double beta=atan2(saturnEarth[2], sqrt(saturnEarth[0]*saturnEarth[0]+saturnEarth[1]*saturnEarth[1]));
+					const double sinx=sin(i)*cos(beta)*sin(lambda-Omega)-cos(i)*sin(beta);
+					double rings = -2.6*sinx + 1.25*sinx*sinx;
+					return -8.88 + d + 0.044*phaseDeg + rings;
+				}
+				if (englishName=="Uranus")
+					return -7.19 + d + 0.0028*phaseDeg;
+				if (englishName=="Neptune")
+					return -6.87 + d;
+				if (englishName=="Pluto")
+					return -1.01 + d + 0.041*phaseDeg;
+
+				break;
+			}
+			case Mueller:
+			{
+				// (1)
+				if (englishName=="Mercury")
+				{
+					double ph50=phaseDeg-50.0;
+					return 1.16 + d + 0.02838*ph50 + 0.0001023*ph50*ph50;
+				}
+				if (englishName=="Venus")
+					return -4.0 + d + 0.01322*phaseDeg + 0.0000004247*phaseDeg*phaseDeg*phaseDeg;
+				if (englishName=="Mars")
+					return -1.3 + d + 0.01486*phaseDeg;
+				if (englishName=="Jupiter")
+					return -8.93 + d;
+				if (englishName=="Saturn")
+				{
+					// add rings computation
+					// implemented from Meeus, Astr.Alg.1992
+					const double jd=core->getJDay();
+					const double T=(jd-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);
+					const Vec3d saturnEarth=getHeliocentricEclipticPos() - ssystem->getEarth()->getHeliocentricEclipticPos();
+					double lambda=atan2(saturnEarth[1], saturnEarth[0]);
+					double beta=atan2(saturnEarth[2], sqrt(saturnEarth[0]*saturnEarth[0]+saturnEarth[1]*saturnEarth[1]));
+					const double sinB=sin(i)*cos(beta)*sin(lambda-Omega)-cos(i)*sin(beta);
+					double rings = -2.6*fabs(sinB) + 1.25*sinB*sinB; // sinx=sinB, saturnicentric latitude of earth. longish, see Meeus.
+					return -8.68 + d + 0.044*phaseDeg + rings;
+				}
+				if (englishName=="Uranus")
+					return -6.85 + d;
+				if (englishName=="Neptune")
+					return -7.05 + d;
+				if (englishName=="Pluto")
+					return -1.0 + d;
+
+				break;
+			}
+			case Harris:
+			case UndefinedAlgorithm:	// activated by default
+			{
+				// (2)
+				if (englishName=="Mercury")
+					return 0.42 + d + .038*phaseDeg - 0.000273*phaseDeg*phaseDeg + 0.000002*phaseDeg*phaseDeg*phaseDeg;
+				if (englishName=="Venus")
+					return -4.40 + d + 0.0009*phaseDeg + 0.000239*phaseDeg*phaseDeg - 0.00000065*phaseDeg*phaseDeg*phaseDeg;
+				if (englishName=="Mars")
+					return -1.52 + d + 0.016*phaseDeg;
+				if (englishName=="Jupiter")
+					return -9.40 + d + 0.005*phaseDeg;
+				if (englishName=="Saturn")
+				{
+					// add rings computation
+					// implemented from Meeus, Astr.Alg.1992
+					const double jd=core->getJDay();
+					const double T=(jd-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);
+					const Vec3d saturnEarth=getHeliocentricEclipticPos() - ssystem->getEarth()->getHeliocentricEclipticPos();
+					double lambda=atan2(saturnEarth[1], saturnEarth[0]);
+					double beta=atan2(saturnEarth[2], sqrt(saturnEarth[0]*saturnEarth[0]+saturnEarth[1]*saturnEarth[1]));
+					const double sinB=sin(i)*cos(beta)*sin(lambda-Omega)-cos(i)*sin(beta);
+					double rings = -2.6*fabs(sinB) + 1.25*sinB*sinB; // sinx=sinB, saturnicentric latitude of earth. longish, see Meeus.
+					return -8.88 + d + 0.044*phaseDeg + rings;
+				}
+				if (englishName=="Uranus")
+					return -7.19f + d;
+				if (englishName=="Neptune")
+					return -6.87f + d;
+				if (englishName=="Pluto")
+					return -1.00f + d;
+
+				break;
+			}
+		}
 	}
 
 	// This formula seems to give wrong results
@@ -1707,3 +1746,8 @@
 	labelsFader.update(deltaTime);
 	orbitFader.update(deltaTime);
 }
+
+void Planet::setApparentMagnitudeAlgorithm(QString algorithm)
+{
+	vMagAlgorithm = vMagAlgorithmMap.key(algorithm.toLower(), Planet::UndefinedAlgorithm);
+}
 
=== modified file 'src/core/modules/Planet.hpp'
--- src/core/modules/Planet.hpp	2014-08-31 10:34:41 +0000
+++ src/core/modules/Planet.hpp	2014-11-01 17:59:05 +0000
@@ -76,6 +76,7 @@
 	friend class SolarSystem;
 
 	Q_ENUMS(PlanetType)
+	Q_ENUMS(ApparentMagnitudeAlgorithm)
 	//! numeric typecodes for the type descriptions in ssystem.ini
 	// GZ: Until 0.13 QStrings were used for types.
 	// GZ: Enums are slightly faster than string comparisons in time-critical comparisons.
@@ -91,6 +92,14 @@
 		isUNDEFINED               // ssystem.ini: type=<anything else>
 	};
 
+	enum ApparentMagnitudeAlgorithm
+	{
+		Planesas,	// Algorithm provided by Pere Planesas (Observatorio Astronomico Nacional)
+		Mueller,	// G. Mueller, based on visual observations 1877-91. [Expl.Suppl.1961]
+		Harris,		// Astronomical Almanac 1984 and later. These give V (instrumental) magnitudes (D.L. Harris)
+		UndefinedAlgorithm
+	};
+
 	Planet(const QString& englishName,
 	       int flagLighting,
 	       double radius,
@@ -170,6 +179,10 @@
 	const QString getPlanetTypeString() const {return pTypeMap.value(pType);}
 	PlanetType getPlanetType() const {return pType;}
 
+	ApparentMagnitudeAlgorithm getApparentMagnitudeAlgorithm() const { return vMagAlgorithm; }
+	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;
 	Mat4d getRotEquatorialToVsop87(void) const;
@@ -313,13 +326,15 @@
 	bool flagLabels;                 // Define whether labels should be displayed
 	bool hidden;                     // useful for fake planets used as observation positions - not drawn or labeled
 	bool atmosphere;                 // Does the planet have an atmosphere?
-	bool halo;                       // Does the planet have a halo?
-	// QString pTypeStr;			 // Type of body, old version just had a string here.
-	PlanetType pType;                // GZ this is now a proper type...
+	bool halo;                       // Does the planet have a halo?	
+	PlanetType pType;                // Type of body
+
+	ApparentMagnitudeAlgorithm vMagAlgorithm;
 
 	static Vec3f labelColor;
 	static StelTextureSP hintCircleTex;
-	static QMap<PlanetType, QString> pTypeMap; // GZ: maps fast type to english name.
+	static QMap<PlanetType, QString> pTypeMap; // Maps fast type to english name.
+	static QMap<ApparentMagnitudeAlgorithm, QString> vMagAlgorithmMap;
 	
 	// Shader-related variables
 	struct PlanetShaderVars {
 
=== modified file 'src/core/modules/SolarSystem.cpp'
--- src/core/modules/SolarSystem.cpp	2014-08-31 10:34:41 +0000
+++ src/core/modules/SolarSystem.cpp	2014-11-01 17:59:05 +0000
@@ -136,6 +136,9 @@
 	setFlagOrbits(conf->value("astro/flag_planets_orbits").toBool());
 	setFlagLightTravelTime(conf->value("astro/flag_light_travel_time", false).toBool());
 	setFlagMarkers(conf->value("astro/flag_planets_markers", true).toBool());
+	// Set the algorithm from Astronomical Almanac for computation of apparent magnitudes for
+	// planets in case  observer on the Earth by default
+	setApparentMagnitudeAlgorithmOnEarth(conf->value("astro/apparent_magnitude_algorithm", "Harris").toString());
 
 	recreateTrails();
 
@@ -1520,3 +1523,15 @@
 	// Restore translations
 	updateI18n();
 }
+
+// Set the algorithm for computation of apparent magnitudes for planets in case  observer on the Earth
+void SolarSystem::setApparentMagnitudeAlgorithmOnEarth(QString algorithm)
+{
+	getEarth()->setApparentMagnitudeAlgorithm(algorithm);
+}
+
+// Get the algorithm used for computation of apparent magnitudes for planets in case  observer on the Earth
+QString SolarSystem::getApparentMagnitudeAlgorithmOnEarth() const
+{
+	return getEarth()->getApparentMagnitudeAlgorithmString();
+}
 
=== modified file 'src/core/modules/SolarSystem.hpp'
--- src/core/modules/SolarSystem.hpp	2014-08-30 16:58:25 +0000
+++ src/core/modules/SolarSystem.hpp	2014-11-01 17:59:05 +0000
@@ -261,6 +261,24 @@
 	//! @return a phase
 	float getPhaseForPlanet(QString planetName) const;
 
+	//! Set the algorithm for computation of apparent magnitudes for planets in case observer on the Earth.
+	//! Possible values:
+	//! * Planesas (algorithm provided by Pere Planesas (Observatorio Astronomico Nacional))
+	//! * Mueller (G. Mueller, based on visual observations 1877-91. [Expl.Suppl.1961])
+	//! * Harris (Astronomical Almanac 1984 and later. These give V (instrumental) magnitudes)
+	//! Details:
+	//! J. Meeus "Astronomical Algorithms" (2nd ed., with corrections as of August 10, 2009) p.283-286.
+	//! O. Montenbruck, T. Pfleger "Astronomy on the Personal Computer" (4th ed.) p.143-145.
+	//! Daniel L. Harris "Photometry and Colorimetry of Planets and Satellites" http://adsabs.harvard.edu/abs/1961plsa.book..272H
+	//! Hint: Default option in config.ini: astro/apparent_magnitude_algorithm = Harris
+	//! @param algorithm the case in-sensitive algorithm name
+	//! @note: The structure of algorithms is almost identical, just the numbers are different! You should activate
+	//! Mueller's algorithm for simulate the eye's impression. (Esp. Venus!)
+	void setApparentMagnitudeAlgorithmOnEarth(QString algorithm);
+
+	//! Get the algorithm used for computation of apparent magnitudes for planets in case  observer on the Earth
+	QString getApparentMagnitudeAlgorithmOnEarth() const;
+
 public:
 	///////////////////////////////////////////////////////////////////////////
 	// Other public methods