(lambda_enhancements) fix cCalculateLambdaNanjing headers

Author: themikelau

src/BaseStar.cpp

@@ -1119,7 +1119,7 @@ double BaseStar::EvaluateLambdaNanjing() const {
             }
         }
     }
-    else {return BaseStar::CalculateLambdaNanjing(mass, m_Metallicity);}                                        // Use default Nanjing Lambda's as implemented in STARTRACK (no mass nor metallicity interpolation)
+    else { return CalculateLambdaNanjing(mass, m_Metallicity); }
 }
 
 
@@ -1193,15 +1193,15 @@ double BaseStar::CalculateMassInterpolatedLambdaNanjing(const double p_Mass, con
 double BaseStar::CalculateZInterpolatedLambdaNanjing(const double p_Z, const int p_MassInd) const {
 
     if (utils::Compare(m_Metallicity, LAMBDA_NANJING_POPII_Z) < 0) {
-        return BaseStar::CalculateLambdaNanjingEnhanced(p_MassInd, 0);                       // Use lambda for pop. II metallicity
+        return CalculateLambdaNanjingEnhanced(p_MassInd, 0);                       // Use lambda for pop. II metallicity
     }
     else if (utils::Compare(m_Metallicity, LAMBDA_NANJING_POPI_Z) > 0) {
-        return BaseStar::CalculateLambdaNanjingEnhanced(p_MassInd, 1);                       // Use lambda for pop. I metallicity
+        return CalculateLambdaNanjingEnhanced(p_MassInd, 1);                       // Use lambda for pop. I metallicity
     }
-    else {                                                                                   // Linear interpolation in logZ between pop. I and pop. II metallicities
+    else {                                                                         // Linear interpolation in logZ between pop. I and pop. II metallicities
         const double logZ = log(m_Metallicity);
-        double lambdaLow = BaseStar::CalculateLambdaNanjingEnhanced(p_MassInd, 0);
-        double lambdaUp  = BaseStar::CalculateLambdaNanjingEnhanced(p_MassInd, 1);
+        double lambdaLow = CalculateLambdaNanjingEnhanced(p_MassInd, 0);
+        double lambdaUp  = CalculateLambdaNanjingEnhanced(p_MassInd, 1);
         return lambdaLow + (logZ - LAMBDA_NANJING_POPII_LOGZ) / (LAMBDA_NANJING_POPI_LOGZ - LAMBDA_NANJING_POPII_LOGZ) * (lambdaUp - lambdaLow);
     }
 }

src/HeHG.h

@@ -69,7 +69,7 @@ class HeHG: virtual public BaseStar, public HeMS {
             double          CalculateHeCoreMassOnPhase() const                                                      { return m_Mass; }                                                      // NO-OP
 
             double          CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const;
-            double          CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zind) const             { return CalculateLambdaNanjing(0.0, 0.0); }                            // 0.0's are dummy integers that are not used 
+            double          CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zind) const             { return CalculateLambdaNanjing(0.0, 0.0); }                            // 0.0 are dummy values that are not used
 
             double          CalculateLuminosityOnPhase() const;
             double          CalculateLuminosityAtPhaseEnd() const                                                   { return m_Luminosity; }                                                // NO-OP

src/HeMS.h

@@ -69,7 +69,8 @@ class HeMS: virtual public BaseStar, public TPAGB {
             double          CalculateInitialSupernovaMass() const                                       { return GiantBranch::CalculateInitialSupernovaMass(); }                // Use GiantBranch
 
             double          CalculateLambdaDewi() const                                                 { return 0.5; }
-            double          CalculateLambdaNanjing() const                                              { return BaseStar::CalculateLambdaNanjing(0.0, 0.0); }                  // Not supported - use BaseStar (0.0 are dummy values)
+            double          CalculateLambdaNanjing(const double p_Mass,
+                                                   const double p_Metallicity) const                    { return BaseStar::CalculateLambdaNanjing(0.0, 0.0); }                  // Not supported - use BaseStar (0.0 are dummy values)
             double          CalculateLuminosityAtPhaseEnd(const double p_Mass) const                    { return CalculateLuminosityAtPhaseEnd_Static(p_Mass); }
             double          CalculateLuminosityAtPhaseEnd() const                                       { return CalculateLuminosityAtPhaseEnd(m_Mass); }                       // Use class member variables
             double          CalculateLuminosityOnPhase(const double p_Mass, const double p_Tau) const   { return CalculateLuminosityOnPhase_Static(p_Mass, p_Tau); }

src/HeWD.h

@@ -48,6 +48,7 @@ class HeWD: virtual public BaseStar, public WhiteDwarfs {
     // member functions - alphabetically
     double  CalculateLambdaDewi()                                                         { return BaseStar::CalculateLambdaDewi(); }                                     // Not supported - use BaseStar
     double  CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const { return BaseStar::CalculateLambdaNanjing(0.0, 0.0); }                          // Not supported - use BaseStar (0.0 are dummy values)    JR: todo: check this (type 10 not mentioned as not supported in original code)
+    double  CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zind) const   { return CalculateLambdaNanjing(0.0, 0.0); }                            // 0.0 are dummy values that are not used
     double  CalculateLuminosityOnPhase(const double p_Mass,
                                        const double p_Time,
                                        const double p_Metallicity) const                  { return CalculateLuminosityOnPhase_Static(p_Mass, p_Time, p_Metallicity); }

src/Remnants.h

@@ -45,7 +45,7 @@ class Remnants: virtual public BaseStar, public HeGB {
     double          CalculateInitialSupernovaMass() const                                                       { return GiantBranch::CalculateInitialSupernovaMass(); }                // Use GiantBranch
 
     double          CalculateLambdaDewi() const                                                                 { return BaseStar::CalculateLambdaDewi(); }                             // Not supported - use BaseStar
-    double          CalculateLambdaNanjing() const                                                              { return BaseStar::CalculateLambdaNanjing(0.0, 0.0); }                  // Not supported - use BaseStar (0.0 are dummy values)      JR: todo: check this (type 10 not mentioned as not supported in original code)
+    double          CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const               { return BaseStar::CalculateLambdaNanjing(0.0, 0.0); }                  // Not supported - use BaseStar (0.0 are dummy values)      JR: todo: check this (type 10 not mentioned as not supported in original code)
 
     DBL_DBL         CalculateMassAcceptanceRate(const double p_DonorMassRate,
                                                     const double p_AccretorMassRate = 0.0);