(lambda_enhancements) rename CalculateLambdaNanjing to CalculateLambdaNanjingStartrack

themikelau · themikelau · commit a093167cf80b · 2022-01-12T18:12:41.000+11:00
diff --git a/src/BaseStar.cpp b/src/BaseStar.cpp
@@ -1088,11 +1088,11 @@ double BaseStar::CalculateLambdaLoveridgeEnergyFormalism(const double p_EnvMass,
  * Wrapper function to return Nanjing lambda based on options
  * 
  * 
- * double BaseStar::EvaluateLambdaNanjing()
+ * double BaseStar::CalculateLambdaNanjing()
  * 
  * @return                                      Common envelope lambda parameter
  */ 
-double BaseStar::EvaluateLambdaNanjing() const {
+double BaseStar::CalculateLambdaNanjing() const {
 
     double mass = m_MZAMS;
     double lambda = 0.0;
@@ -1121,8 +1121,8 @@ double BaseStar::EvaluateLambdaNanjing() const {
             }
         }
     }
-    else { lambda = CalculateLambdaNanjing(mass, m_Metallicity); }
-    return lambda
+    else { lambda = CalculateLambdaNanjingStarTrack(mass, m_Metallicity); }
+    return lambda;
 }
 
 
@@ -1149,7 +1149,7 @@ double BaseStar::CalculateMassAndZInterpolatedLambdaNanjing(const double p_Mass,
         double lambdaUp  = BaseStar::CalculateMassInterpolatedLambdaNanjing(p_Mass, 1);
         lambda = lambdaLow + (logZ - LAMBDA_NANJING_POPII_LOGZ) / (LAMBDA_NANJING_POPI_LOGZ - LAMBDA_NANJING_POPII_LOGZ) * (lambdaUp - lambdaLow);
     }
-    return lambda
+    return lambda;
 }
 
 
@@ -1183,7 +1183,7 @@ double BaseStar::CalculateMassInterpolatedLambdaNanjing(const double p_Mass, con
         double lambdaUp  = CalculateLambdaNanjingEnhanced(up, p_Zind);
         lambda = lambdaLow + (p_Mass - NANJING_MASSES[low]) / (NANJING_MASSES[up] - NANJING_MASSES[low]) * (lambdaUp - lambdaLow);
     }
-    return lambda
+    return lambda;
 }
 
 
@@ -1212,7 +1212,7 @@ double BaseStar::CalculateZInterpolatedLambdaNanjing(const double p_Z, const int
         double lambdaUp  = CalculateLambdaNanjingEnhanced(p_MassInd, 1);
         lambda = lambdaLow + (logZ - LAMBDA_NANJING_POPII_LOGZ) / (LAMBDA_NANJING_POPI_LOGZ - LAMBDA_NANJING_POPII_LOGZ) * (lambdaUp - lambdaLow);
     }
-    return lambda
+    return lambda;
 }
 
 
@@ -1332,7 +1332,7 @@ double BaseStar::CalculateZadiabatic(ZETA_PRESCRIPTION p_ZetaPrescription) {
 void BaseStar::CalculateLambdas(const double p_EnvMass) {
 
     m_Lambdas.fixed          = OPTIONS->CommonEnvelopeLambda();
-	m_Lambdas.nanjing        = EvaluateLambdaNanjing();
+	m_Lambdas.nanjing        = CalculateLambdaNanjing();
 	m_Lambdas.loveridge      = CalculateLambdaLoveridgeEnergyFormalism(p_EnvMass, false);
 	m_Lambdas.loveridgeWinds = CalculateLambdaLoveridgeEnergyFormalism(p_EnvMass, true);      
 	m_Lambdas.kruckow        = CalculateLambdaKruckow(m_Radius, OPTIONS->CommonEnvelopeSlopeKruckow());
diff --git a/src/BaseStar.h b/src/BaseStar.h
@@ -386,7 +386,7 @@ class BaseStar {
     virtual double              CalculateLambdaDewi() const                                                             { SHOW_WARN(ERROR::NO_LAMBDA_DEWI, "Default used: 1.0"); return 1.0; }      // Not supported: show error
             double              CalculateLambdaKruckow(const double p_Radius, const double p_Alpha) const;
             double              CalculateLambdaLoveridgeEnergyFormalism(const double p_EnvMass, const double p_IsMassLoss = false) const;
-    virtual double              CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const           { SHOW_WARN(ERROR::NO_LAMBDA_NANJING, "Default used: 1.0"); return 1.0; }   // Not supported: show error
+    virtual double              CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const           { SHOW_WARN(ERROR::NO_LAMBDA_NANJING, "Default used: 1.0"); return 1.0; }   // Not supported: show error
     virtual double              CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zind) const             { SHOW_WARN(ERROR::NO_LAMBDA_NANJING, "Default used: 1.0"); return 1.0; }   // Not supported: show error
 
             void                CalculateLCoefficients(const double p_LogMetallicityXi, DBL_VECTOR &p_LCoefficients);
@@ -503,7 +503,7 @@ class BaseStar {
                                                     const double p_EjectaMass,
                                                     const double p_RemnantMass) const;
 
-            double              EvaluateLambdaNanjing() const;
+            double              CalculateLambdaNanjing() const;
     virtual void                EvolveOneTimestepPreamble() { };                                                                                                                                    // Default is NO-OP
 
             STELLAR_TYPE        EvolveOnPhase();
diff --git a/src/CHeB.cpp b/src/CHeB.cpp
@@ -468,11 +468,11 @@ double CHeB::CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zin
  * This function good for CHeB stars.
  *
  *
- * double CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity)
+ * double CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity)
  *
  * @return                                      Nanjing lambda for use in common envelope
  */
-double CHeB::CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const {
+double CHeB::CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const {
 
 	DBL_VECTOR maxBG    = {};                                                       // [0] = maxB, [1] = maxG
 	DBL_VECTOR lambdaBG = {};                                                       // [0] = lambdaB, [1] = lambdaG
diff --git a/src/CHeB.h b/src/CHeB.h
@@ -72,7 +72,7 @@ class CHeB: virtual public BaseStar, public FGB {
     double          CalculateGyrationRadius() const                             { return 0.21; }                                                                // Hurley et al., 2000, after eq 109 for n=3/2 polytrope or dense convective core. Single number approximation.
 
     double          CalculateLambdaDewi() const;
-    double          CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const;
+    double          CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const;
     double          CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zind) const;
 
     double          CalculateLifetimeOnBluePhase(const double p_Mass);
diff --git a/src/EAGB.cpp b/src/EAGB.cpp
@@ -371,11 +371,11 @@ double EAGB::CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zin
  * This function good for EAGB stars.
  *
  *
- * double CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity)
+ * double CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity)
  *
  * @return                                      Nanjing lambda for use in common envelope
  */
-double EAGB::CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const {
+double EAGB::CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const {
 
 	DBL_VECTOR maxBG    = {};                                                       // [0] = maxB, [1] = maxG
 	DBL_VECTOR lambdaBG = {};                                                       // [0] = lambdaB, [1] = lambdaG
diff --git a/src/EAGB.h b/src/EAGB.h
@@ -58,7 +58,7 @@ class EAGB: virtual public BaseStar, public CHeB {
 
     double          CalculateInitialSupernovaMass() const                                           { return m_GBParams[static_cast<int>(GBP::McBAGB)]; }               // For EAGB & TPAGB we use the mass at Base Asymptotic Giant Branch to determine SN type
 
-    double          CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const;
+    double          CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const;
     double          CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zind) const;
 
     double          CalculateLifetimeTo2ndDredgeUp(const double p_Tinf1_FAGB, const double p_Tinf2_FAGB) const;
diff --git a/src/HG.cpp b/src/HG.cpp
@@ -379,11 +379,11 @@ double HG::CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zind)
  * This function good for HG and FGB stars.
  *
  *
- * double CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity)
+ * double CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity)
  *
  * @return                                      Nanjing lambda for use in common envelope
  */
-double HG::CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const {
+double HG::CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const {
 
 	DBL_VECTOR maxBG    = {};                                                           // [0] = maxB, [1] = maxG
 	DBL_VECTOR lambdaBG = {};                                                           // [0] = lambdaB, [1] = lambdaG
diff --git a/src/HG.h b/src/HG.h
@@ -64,7 +64,7 @@ class HG: virtual public BaseStar, public GiantBranch {
     double          CalculateHeCoreMassOnPhase() const                              { return m_CoreMass; }                                                                      // McHe(HG) = Core Mass
 
     double          CalculateLambdaDewi() const;
-    double          CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const;
+    double          CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const;
     double          CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zind) const;
 
     double          CalculateLuminosityAtPhaseEnd(const double p_Mass) const;
diff --git a/src/HeHG.cpp b/src/HeHG.cpp
@@ -292,11 +292,11 @@ double HeHG::CalculatePerturbationMu() const {
  * This function good for HeHG and HeGB stars (for Helium stars: always use Natasha's fit)
  *
  *
- * double CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity)
+ * double CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity)
  *
  * @return                                      Nanjing lambda for use in common envelope
  */
-double HeHG::CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const {
+double HeHG::CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const {
 
     double rMin = 0.25;                              // minimum considered radius: Natasha       JR: todo: should this be in constants.h?
 	double rMax = 120.0;                             // maximum considered radius: Natasha       JR: todo: should this be in constants.h?
diff --git a/src/HeHG.h b/src/HeHG.h
@@ -68,8 +68,8 @@ class HeHG: virtual public BaseStar, public HeMS {
             double          CalculateHeCoreMassAtPhaseEnd() const                                                   { return CalculateHeCoreMassOnPhase(); }                                // Same as on phase
             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 are dummy values that are not used
+            double          CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const;
+            double          CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zind) const             { return CalculateLambdaNanjingStarTrack(0.0, 0.0); }                            // 0.0 are dummy values that are not used
 
             double          CalculateLuminosityOnPhase() const;
             double          CalculateLuminosityAtPhaseEnd() const                                                   { return m_Luminosity; }                                                // NO-OP
diff --git a/src/HeMS.h b/src/HeMS.h
@@ -69,8 +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 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          CalculateLambdaNanjingStarTrack(const double p_Mass,
+                                                   const double p_Metallicity) const                    { return BaseStar::CalculateLambdaNanjingStarTrack(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); }
diff --git a/src/HeWD.h b/src/HeWD.h
@@ -47,8 +47,8 @@ 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  CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const { return BaseStar::CalculateLambdaNanjingStarTrack(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 CalculateLambdaNanjingStarTrack(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); }
diff --git a/src/Remnants.h b/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 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          CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const               { return BaseStar::CalculateLambdaNanjingStarTrack(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);
diff --git a/src/TPAGB.cpp b/src/TPAGB.cpp
@@ -389,11 +389,11 @@ double TPAGB::CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zi
  * This function good for TPAGB stars.
  *
  *
- * double CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity)
+ * double CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity)
  *
  * @return                                      Nanjing lambda for use in common envelope
  */
-double TPAGB::CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const {
+double TPAGB::CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const {
 
 	DBL_VECTOR maxBG    = {};                                                       // [0] = maxB, [1] = maxG
 	DBL_VECTOR lambdaBG = {};                                                       // [0] = lambdaB, [1] = lambdaG
diff --git a/src/TPAGB.h b/src/TPAGB.h
@@ -50,7 +50,7 @@ class TPAGB: virtual public BaseStar, public EAGB {
             double          CalculateHeCoreMassOnPhase() const                                                      { return m_CoreMass; }                                                                  // NO-OP
 
             double          CalculateLambdaDewi() const;
-            double          CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const;
+            double          CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const;
             double          CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zind) const;
 
             double          CalculateLuminosityOnPhase(const double p_Time) const;

Original file line number	Diff line number	Diff line change
`@@ -1088,11 +1088,11 @@ double BaseStar::CalculateLambdaLoveridgeEnergyFormalism(const double p_EnvMass,`
`1088`	`1088`	`* Wrapper function to return Nanjing lambda based on options`
`1089`	`1089`	`*`
`1090`	`1090`	`*`
`1091`		`- * double BaseStar::EvaluateLambdaNanjing()`
	`1091`	`+ * double BaseStar::CalculateLambdaNanjing()`
`1092`	`1092`	`*`
`1093`	`1093`	`* @return Common envelope lambda parameter`
`1094`	`1094`	`*/`
`1095`		`-double BaseStar::EvaluateLambdaNanjing() const {`
	`1095`	`+double BaseStar::CalculateLambdaNanjing() const {`
`1096`	`1096`
`1097`	`1097`	`double mass = m_MZAMS;`
`1098`	`1098`	`double lambda = 0.0;`
`@@ -1121,8 +1121,8 @@ double BaseStar::EvaluateLambdaNanjing() const {`
`1121`	`1121`	`}`
`1122`	`1122`	`}`
`1123`	`1123`	`}`
`1124`		`- else { lambda = CalculateLambdaNanjing(mass, m_Metallicity); }`
`1125`		`- return lambda`
	`1124`	`+ else { lambda = CalculateLambdaNanjingStarTrack(mass, m_Metallicity); }`
	`1125`	`+ return lambda;`
`1126`	`1126`	`}`
`1127`	`1127`
`1128`	`1128`
`@@ -1149,7 +1149,7 @@ double BaseStar::CalculateMassAndZInterpolatedLambdaNanjing(const double p_Mass,`
`1149`	`1149`	`double lambdaUp = BaseStar::CalculateMassInterpolatedLambdaNanjing(p_Mass, 1);`
`1150`	`1150`	`lambda = lambdaLow + (logZ - LAMBDA_NANJING_POPII_LOGZ) / (LAMBDA_NANJING_POPI_LOGZ - LAMBDA_NANJING_POPII_LOGZ) * (lambdaUp - lambdaLow);`
`1151`	`1151`	`}`
`1152`		`- return lambda`
	`1152`	`+ return lambda;`
`1153`	`1153`	`}`
`1154`	`1154`
`1155`	`1155`
`@@ -1183,7 +1183,7 @@ double BaseStar::CalculateMassInterpolatedLambdaNanjing(const double p_Mass, con`
`1183`	`1183`	`double lambdaUp = CalculateLambdaNanjingEnhanced(up, p_Zind);`
`1184`	`1184`	`lambda = lambdaLow + (p_Mass - NANJING_MASSES[low]) / (NANJING_MASSES[up] - NANJING_MASSES[low]) * (lambdaUp - lambdaLow);`
`1185`	`1185`	`}`
`1186`		`- return lambda`
	`1186`	`+ return lambda;`
`1187`	`1187`	`}`
`1188`	`1188`
`1189`	`1189`
`@@ -1212,7 +1212,7 @@ double BaseStar::CalculateZInterpolatedLambdaNanjing(const double p_Z, const int`
`1212`	`1212`	`double lambdaUp = CalculateLambdaNanjingEnhanced(p_MassInd, 1);`
`1213`	`1213`	`lambda = lambdaLow + (logZ - LAMBDA_NANJING_POPII_LOGZ) / (LAMBDA_NANJING_POPI_LOGZ - LAMBDA_NANJING_POPII_LOGZ) * (lambdaUp - lambdaLow);`
`1214`	`1214`	`}`
`1215`		`- return lambda`
	`1215`	`+ return lambda;`
`1216`	`1216`	`}`
`1217`	`1217`
`1218`	`1218`
`@@ -1332,7 +1332,7 @@ double BaseStar::CalculateZadiabatic(ZETA_PRESCRIPTION p_ZetaPrescription) {`
`1332`	`1332`	`void BaseStar::CalculateLambdas(const double p_EnvMass) {`
`1333`	`1333`
`1334`	`1334`	`m_Lambdas.fixed = OPTIONS->CommonEnvelopeLambda();`
`1335`		`- m_Lambdas.nanjing = EvaluateLambdaNanjing();`
	`1335`	`+ m_Lambdas.nanjing = CalculateLambdaNanjing();`
`1336`	`1336`	`m_Lambdas.loveridge = CalculateLambdaLoveridgeEnergyFormalism(p_EnvMass, false);`
`1337`	`1337`	`m_Lambdas.loveridgeWinds = CalculateLambdaLoveridgeEnergyFormalism(p_EnvMass, true);`
`1338`	`1338`	`m_Lambdas.kruckow = CalculateLambdaKruckow(m_Radius, OPTIONS->CommonEnvelopeSlopeKruckow());`
Original file line number	Diff line number	Diff line change
`@@ -468,11 +468,11 @@ double CHeB::CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zin`
`468`	`468`	`* This function good for CHeB stars.`
`469`	`469`	`*`
`470`	`470`	`*`
`471`		`- * double CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity)`
	`471`	`+ * double CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity)`
`472`	`472`	`*`
`473`	`473`	`* @return Nanjing lambda for use in common envelope`
`474`	`474`	`*/`
`475`		`-double CHeB::CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const {`
	`475`	`+double CHeB::CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const {`
`476`	`476`
`477`	`477`	`DBL_VECTOR maxBG = {}; // [0] = maxB, [1] = maxG`
`478`	`478`	`DBL_VECTOR lambdaBG = {}; // [0] = lambdaB, [1] = lambdaG`
Original file line number	Diff line number	Diff line change
`@@ -371,11 +371,11 @@ double EAGB::CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zin`
`371`	`371`	`* This function good for EAGB stars.`
`372`	`372`	`*`
`373`	`373`	`*`
`374`		`- * double CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity)`
	`374`	`+ * double CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity)`
`375`	`375`	`*`
`376`	`376`	`* @return Nanjing lambda for use in common envelope`
`377`	`377`	`*/`
`378`		`-double EAGB::CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const {`
	`378`	`+double EAGB::CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const {`
`379`	`379`
`380`	`380`	`DBL_VECTOR maxBG = {}; // [0] = maxB, [1] = maxG`
`381`	`381`	`DBL_VECTOR lambdaBG = {}; // [0] = lambdaB, [1] = lambdaG`
Original file line number	Diff line number	Diff line change
`@@ -379,11 +379,11 @@ double HG::CalculateLambdaNanjingEnhanced(const int p_MassInd, const int p_Zind)`
`379`	`379`	`* This function good for HG and FGB stars.`
`380`	`380`	`*`
`381`	`381`	`*`
`382`		`- * double CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity)`
	`382`	`+ * double CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity)`
`383`	`383`	`*`
`384`	`384`	`* @return Nanjing lambda for use in common envelope`
`385`	`385`	`*/`
`386`		`-double HG::CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const {`
	`386`	`+double HG::CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const {`
`387`	`387`
`388`	`388`	`DBL_VECTOR maxBG = {}; // [0] = maxB, [1] = maxG`
`389`	`389`	`DBL_VECTOR lambdaBG = {}; // [0] = lambdaB, [1] = lambdaG`
Original file line number	Diff line number	Diff line change
`@@ -292,11 +292,11 @@ double HeHG::CalculatePerturbationMu() const {`
`292`	`292`	`* This function good for HeHG and HeGB stars (for Helium stars: always use Natasha's fit)`
`293`	`293`	`*`
`294`	`294`	`*`
`295`		`- * double CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity)`
	`295`	`+ * double CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity)`
`296`	`296`	`*`
`297`	`297`	`* @return Nanjing lambda for use in common envelope`
`298`	`298`	`*/`
`299`		`-double HeHG::CalculateLambdaNanjing(const double p_Mass, const double p_Metallicity) const {`
	`299`	`+double HeHG::CalculateLambdaNanjingStarTrack(const double p_Mass, const double p_Metallicity) const {`
`300`	`300`
`301`	`301`	`double rMin = 0.25; // minimum considered radius: Natasha JR: todo: should this be in constants.h?`
`302`	`302`	`double rMax = 120.0; // maximum considered radius: Natasha JR: todo: should this be in constants.h?`