wip

Author: Askaniy

src/celastro/astro.cpp

@@ -56,40 +56,49 @@ negateIf(double& d, bool condition)
 
 
 // Computes the luminosity of a perfectly reflective disc.
-// It can be used as an upper bound for the irradiance of an object when culling invisible objects.
+// It is also used as an upper bound for the irradiance of an object when culling invisible objects.
 // The function translates luminosity into luminosity of the same units
 // (distanceFromSun and objRadius must also be in the same units).
-static float reflectedLuminosity(float sunLuminosity,
-                                 float distanceFromSun,
-                                 float objRadius)
+float reflectedLuminosity(float sunLuminosity,
+                          float distanceFromSun,
+                          float objRadius)
 {
     float lengthRatio = objRadius / distanceFromSun;
     return sunLuminosity * 0.25 * lengthRatio * lengthRatio;
 }
 
 
-// Return the absolute magnitude of a star with lum times solar absolute luminosity
+// The following notation rules apply in the functions below and in the code in general:
+// - Luminosity is implied in solar units (in SI, flux is measured in W)
+// - Irradiance is implied in vegan units (in SI, it is measured in W/m^2)
+
+// Absolute magnitude is the logarithmic inverse of luminosity.
+// Apparent magnitude is the logarithmic inverse of irradiance.
+
+
+// Luminosity conversions:
+
 float
 lumToAbsMag(float lum)
 {
     return SOLAR_ABSMAG - std::log(lum) * LN_MAG;
 }
 
-// Return the apparent magnitude of a star with lum times solar luminosity viewed at lyrs light years
 float
 lumToAppMag(float lum, float lyrs)
 {
     return absToAppMag(lumToAbsMag(lum), lyrs);
 }
 
-// Return the irradiance of a star in Vega units with lum times solar luminosity viewed at the distance in km
 float
 lumToIrradiance(float lum, float km)
 {
     return lum * SOLAR_POWER / (math::sphereArea(km * 1000) * VEGAN_IRRADIANCE);
 }
 
 
+// Magnitude conversions:
+
 float
 absMagToLum(float mag)
 {
@@ -108,14 +117,17 @@ absMagToIrradiance(float mag, float km)
     return lumToIrradiance(absMagToLum(mag), km);
 }
 
-// Conversions between the magnitude system and irradiance in Vega units
+
+// Logarithmic magnitude system <-> linear irradiance system in Vega units:
+
 float
 magToIrradiance(float mag)
 {
     return std::exp(- mag / LN_MAG);
     // slower solution:
     // return std::pow(10.0f, -0.4f * mag);
 }
+
 float
 irradianceToMag(float irradiance)
 {
@@ -124,14 +136,17 @@ irradianceToMag(float irradiance)
     // return -2.5f * std::log10(irradiance);
 }
 
-// Conversions between the faintest star magnitude system and exposure
+
+// Faintest star magnitude system <-> exposure time:
+
 float
 faintestMagToExposure(float faintestMag)
 {
     return std::exp(faintestMag / LN_MAG) * IRRADIATION_LIMIT;
     // slower solution:
     // return std::pow(10.0f, 0.4f * faintestMag) * IRRADIATION_LIMIT;
 }
+
 float
 exposureToFaintestMag(float exposure)
 {
@@ -140,6 +155,7 @@ exposureToFaintestMag(float exposure)
     // return 2.5f * std::log10(exposure / IRRADIATION_LIMIT);
 }
 
+
 void
 decimalToDegMinSec(double angle, int& degrees, int& minutes, double& seconds)
 {

src/celastro/astro.h

@@ -72,7 +72,7 @@ constexpr inline auto JUPITER_RADIUS = detail::enable_if_fp<T>(71492.0L);
 template<typename T>
 constexpr inline auto SOLAR_RADIUS = detail::enable_if_fp<T>(696000.0L);
 
-static float reflectedLuminosity(float sunLuminosity, float distanceFromSun, float objRadius);
+float reflectedLuminosity(float sunLuminosity, float distanceFromSun, float objRadius);
 
 // Magnitude conversions
 float lumToAbsMag(float lum);

src/celengine/body.cpp

@@ -824,9 +824,9 @@ float Body::getLuminosity(const Star& sun,
 float Body::getLuminosity(float sunLuminosity,
                           float distanceFromSun) const
 {
-    return getReflectivity() * astro::reflectedLuminosity(float sunLuminosity,
-                                                          float distanceFromSun,
-                                                          float radius);
+    return getReflectivity() * astro::reflectedLuminosity(sunLuminosity,
+                                                          distanceFromSun,
+                                                          radius);
 }
 
 
@@ -893,8 +893,8 @@ float Body::getIrradiance(float sunLuminosity,
                           float distanceFromViewer) const
 {
     // Compute the reflected flux (luminosity) in SI units
-    float reflectedFlux = astro::SOLAR_POWER * getLuminosity(float sunLuminosity,
-                                                             float distanceFromSun);
+    float reflectedFlux = astro::SOLAR_POWER * getLuminosity(sunLuminosity,
+                                                             distanceFromSun);
 
     // Compute the irradiance at the observer's distance from the planet
     float obsIrradiance = reflectedFlux / math::sphereArea(distanceFromViewer * 1000); // km to m