From 8f4b514861269beccc741e234d233543bfc81cea Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Tue, 22 Oct 2024 10:51:07 +0200 Subject: [PATCH 01/36] replaced muller mandel remnant masses with pseudo-NS masses for non-direct collapse --- src/GiantBranch.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index 1602a0b31..bf94207d9 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1374,8 +1374,10 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, if( utils::Compare(p_COCoreMass, M3) >=0 || (utils::Compare(p_COCoreMass, M1) >= 0 && utils::Compare(p_COCoreMass, M2) <= 0) ) // Complete fallback into BH return p_HeCoreMass; else if ( utils::Compare(p_COCoreMass, M2) > 0 && utils::Compare(p_COCoreMass, M3) < 0 && utils::Compare(RAND->Random(0, 1), 0.1) <= 0 ) // Partial fallback BH formation - return CalculateFallbackBHMassMullerMandel(p_COCoreMass, p_HeCoreMass); - return CalculateRemnantNSMassMullerMandel(p_COCoreMass, p_HeCoreMass); + //return CalculateFallbackBHMassMullerMandel(p_COCoreMass, p_HeCoreMass); + return 1.44; // slightly higher mass NS + //return CalculateRemnantNSMassMullerMandel(p_COCoreMass, p_HeCoreMass); + return 1.40; // slightly lower mass NS - just to distinguish it... } From e4125606137fbc6c3dc2b2bc6bac9bdc8ad6cea6 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Tue, 22 Oct 2024 14:19:15 +0200 Subject: [PATCH 02/36] simplified kiril model, in compas --- src/GiantBranch.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index bf94207d9..572096b16 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1314,7 +1314,7 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, double M1, M2, M3; if (utils::Compare(p_COCoreMass, MALTSEV2024_MMIN) < 0) // NS formation regardless of metallicity and MT history - return CalculateRemnantNSMassMullerMandel(p_COCoreMass, p_HeCoreMass); + return 1.35; //CalculateRemnantNSMassMullerMandel(p_COCoreMass, p_HeCoreMass); if (utils::Compare(p_COCoreMass, MALTSEV2024_MMAX) > 0) // BH formation regardless of metallicity and MT history return p_HeCoreMass; @@ -1372,7 +1372,9 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, } if( utils::Compare(p_COCoreMass, M3) >=0 || (utils::Compare(p_COCoreMass, M1) >= 0 && utils::Compare(p_COCoreMass, M2) <= 0) ) // Complete fallback into BH + { return p_HeCoreMass; + } else if ( utils::Compare(p_COCoreMass, M2) > 0 && utils::Compare(p_COCoreMass, M3) < 0 && utils::Compare(RAND->Random(0, 1), 0.1) <= 0 ) // Partial fallback BH formation //return CalculateFallbackBHMassMullerMandel(p_COCoreMass, p_HeCoreMass); return 1.44; // slightly higher mass NS From 73a0833378e64fde76219a616db891eb94e836e3 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Tue, 22 Oct 2024 14:23:41 +0200 Subject: [PATCH 03/36] added 50% fallback --- src/GiantBranch.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index 572096b16..52e34450c 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1376,8 +1376,13 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, return p_HeCoreMass; } else if ( utils::Compare(p_COCoreMass, M2) > 0 && utils::Compare(p_COCoreMass, M3) < 0 && utils::Compare(RAND->Random(0, 1), 0.1) <= 0 ) // Partial fallback BH formation + { //return CalculateFallbackBHMassMullerMandel(p_COCoreMass, p_HeCoreMass); - return 1.44; // slightly higher mass NS + // add 50% fallback back on + double mhe = m_SupernovaDetails.HeCoreMassAtCOFormation; + double mns = 1.44; + return 1.44 + (mhe - mns)*0.5; + } //return CalculateRemnantNSMassMullerMandel(p_COCoreMass, p_HeCoreMass); return 1.40; // slightly lower mass NS - just to distinguish it... } From 2e947dc8e2653c50772cd83350f31c42bdd10971 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Wed, 30 Oct 2024 19:15:47 +0100 Subject: [PATCH 04/36] cosmetic changes --- src/GiantBranch.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index 52e34450c..a2b383925 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1325,10 +1325,10 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, } else { // star was MT donor at least once // determine MT_CASE of first MT event - STELLAR_TYPE mostRecentDonorType = mtHist[0]; // stellar type at first MT event (as donor) - BaseStar* newStar = stellarUtils::NewStar(mostRecentDonorType); // create new (empty) star of correct stellar type - massTransferCase = newStar->DetermineMassTransferTypeAsDonor(); // get MT type as donor - delete newStar; newStar = nullptr; // return the memory allocated for the new star + STELLAR_TYPE stellarTypeAtFirstDonation = mtHist[0]; // stellar type at first MT event (as donor) + BaseStar* newStar = stellarUtils::NewStar(stellarTypeAtFirstDonation); // create new (empty) star of correct stellar type + massTransferCase = newStar->DetermineMassTransferTypeAsDonor(); // get MT type as donor + delete newStar; newStar = nullptr; // return the memory allocated for the new star } // apply the appropriate remnant mass prescription for the chosen MT case From 4ed71831ffaf5bc2729d922b2e1325635a0ef597 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Sat, 10 May 2025 15:49:09 +0200 Subject: [PATCH 05/36] changed extrapolotion of maltsev remnant masses to be nearest neighbor, and added option for fallback fraction --- src/BaseBinaryStar.cpp | 4 ++++ src/GiantBranch.cpp | 41 +++++++++++++++++++++-------------------- src/LogTypedefs.h | 6 ++++++ src/Options.cpp | 14 +++++++++++++- src/Options.h | 8 +++++++- src/typedefs.h | 5 +++++ 6 files changed, 56 insertions(+), 22 deletions(-) diff --git a/src/BaseBinaryStar.cpp b/src/BaseBinaryStar.cpp index ef739b02e..4e00738b9 100644 --- a/src/BaseBinaryStar.cpp +++ b/src/BaseBinaryStar.cpp @@ -874,6 +874,10 @@ void BaseBinaryStar::StashRLOFProperties(const MT_TIMING p_Which) { rlofPropertiesToReset->massLossRateFromDonor = m_MassLossRateInRLOF; rlofPropertiesToReset->accretionEfficiency = m_FractionAccreted; rlofPropertiesToReset->massTransferTimescale = m_MassTransferTimescale; + rlofPropertiesToReset->teff1 = m_Star1->Temperature(); + rlofPropertiesToReset->teff2 = m_Star2->Temperature(); + rlofPropertiesToReset->lum1 = m_Star1->Luminosity(); + rlofPropertiesToReset->lum2 = m_Star2->Luminosity(); } diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index a590ede27..91bd5b143 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1338,27 +1338,28 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, case MT_CASE::NONE: // no history of MT case MT_CASE::OTHER: // if MT happens from naked He stars, WDs, etc., assume that the core properties are not affected - M1 = MALTSEV2024_M1S + (MALTSEV2024_M1S - MALTSEV2024_M1SZ01) * log10Z; - M2 = MALTSEV2024_M2S + (MALTSEV2024_M2S - MALTSEV2024_M2SZ01) * log10Z; - M3 = MALTSEV2024_M3S + (MALTSEV2024_M3S - MALTSEV2024_M3SZ01) * log10Z; + + M1 = std::min(std::max(MALTSEV2024_M1S + (MALTSEV2024_M1S - MALTSEV2024_M1SZ01) * log10Z, MALTSEV2024_M1SZ01), MALTSEV2024_M1S); + M2 = std::min(std::max(MALTSEV2024_M2S + (MALTSEV2024_M2S - MALTSEV2024_M2SZ01) * log10Z, MALTSEV2024_M2SZ01), MALTSEV2024_M2S); + M3 = std::min(std::max(MALTSEV2024_M3S + (MALTSEV2024_M3S - MALTSEV2024_M3SZ01) * log10Z, MALTSEV2024_M3SZ01), MALTSEV2024_M3S); break; - case MT_CASE::A: // case A MT - M1 = MALTSEV2024_M1A + (MALTSEV2024_M1A - MALTSEV2024_M1AZ01) * log10Z; - M2 = MALTSEV2024_M2A + (MALTSEV2024_M2A - MALTSEV2024_M2AZ01) * log10Z; - M3 = MALTSEV2024_M3A + (MALTSEV2024_M3A - MALTSEV2024_M3AZ01) * log10Z; + case MT_CASE::A: // case A MT + M1 = std::min(std::max(MALTSEV2024_M1A + (MALTSEV2024_M1A - MALTSEV2024_M1AZ01) * log10Z, MALTSEV2024_M1AZ01), MALTSEV2024_M1A); + M2 = std::min(std::max(MALTSEV2024_M2A + (MALTSEV2024_M2A - MALTSEV2024_M2AZ01) * log10Z, MALTSEV2024_M2AZ01), MALTSEV2024_M2A); + M3 = std::min(std::max(MALTSEV2024_M3A + (MALTSEV2024_M3A - MALTSEV2024_M3AZ01) * log10Z, MALTSEV2024_M3AZ01), MALTSEV2024_M3A); break; - case MT_CASE::B: // case B MT - M1 = MALTSEV2024_M1B + (MALTSEV2024_M1B - MALTSEV2024_M1BZ01) * log10Z; - M2 = MALTSEV2024_M2B + (MALTSEV2024_M2B - MALTSEV2024_M2BZ01) * log10Z; - M3 = MALTSEV2024_M3B + (MALTSEV2024_M3B - MALTSEV2024_M3BZ01) * log10Z; + case MT_CASE::B: // case B MT + M1 = std::min(std::max(MALTSEV2024_M1B + (MALTSEV2024_M1B - MALTSEV2024_M1BZ01) * log10Z, MALTSEV2024_M1BZ01), MALTSEV2024_M1B); + M2 = std::min(std::max(MALTSEV2024_M2B + (MALTSEV2024_M2B - MALTSEV2024_M2BZ01) * log10Z, MALTSEV2024_M2BZ01), MALTSEV2024_M2B); + M3 = std::min(std::max(MALTSEV2024_M3B + (MALTSEV2024_M3B - MALTSEV2024_M3BZ01) * log10Z, MALTSEV2024_M3BZ01), MALTSEV2024_M3B); break; - case MT_CASE::C: // case C MT - M1 = MALTSEV2024_M1C + (MALTSEV2024_M1C - MALTSEV2024_M1CZ01) * log10Z; - M2 = MALTSEV2024_M2C + (MALTSEV2024_M2C - MALTSEV2024_M2CZ01) * log10Z; - M3 = MALTSEV2024_M3C + (MALTSEV2024_M3C - MALTSEV2024_M3CZ01) * log10Z; + case MT_CASE::C: // case C MT + M1 = std::min(std::max(MALTSEV2024_M1C + (MALTSEV2024_M1C - MALTSEV2024_M1CZ01) * log10Z, MALTSEV2024_M1CZ01), MALTSEV2024_M1C); + M2 = std::min(std::max(MALTSEV2024_M2C + (MALTSEV2024_M2C - MALTSEV2024_M2CZ01) * log10Z, MALTSEV2024_M2CZ01), MALTSEV2024_M2C); + M3 = std::min(std::max(MALTSEV2024_M3C + (MALTSEV2024_M3C - MALTSEV2024_M3CZ01) * log10Z, MALTSEV2024_M3CZ01), MALTSEV2024_M3C); break; default: // unknown MT_CASE @@ -1379,13 +1380,12 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, } else if ( utils::Compare(p_COCoreMass, M2) > 0 && utils::Compare(p_COCoreMass, M3) < 0 && utils::Compare(RAND->Random(0, 1), 0.1) <= 0 ) // Partial fallback BH formation { - //return CalculateFallbackBHMassMullerMandel(p_COCoreMass, p_HeCoreMass); - // add 50% fallback back on + // add fallback back on + m_SupernovaDetails.fallbackFraction = OPTIONS->MaltsevFallback(); double mhe = m_SupernovaDetails.HeCoreMassAtCOFormation; double mns = 1.44; - return 1.44 + (mhe - mns)*0.5; + return 1.44 + (mhe - mns) *m_SupernovaDetails.fallbackFraction; } - //return CalculateRemnantNSMassMullerMandel(p_COCoreMass, p_HeCoreMass); return 1.40; // slightly lower mass NS - just to distinguish it... } @@ -1947,7 +1947,8 @@ STELLAR_TYPE GiantBranch::ResolveCoreCollapseSN() { case REMNANT_MASS_PRESCRIPTION::MALTSEV2024: // Maltsev+ 2024 - m_SupernovaDetails.fallbackFraction = 0.0; // no subsequent kick adjustment by fallback fraction needed; MULLERMANDEL kick prescription should be used + //fallbackfraction determined interally + //m_SupernovaDetails.fallbackFraction = 0.0; // no subsequent kick adjustment by fallback fraction needed; MULLERMANDEL kick prescription should be used m_Mass = CalculateRemnantMassByMaltsev2024(m_COCoreMass, m_HeCoreMass); break; diff --git a/src/LogTypedefs.h b/src/LogTypedefs.h index 382d46159..716e4bd76 100644 --- a/src/LogTypedefs.h +++ b/src/LogTypedefs.h @@ -806,6 +806,9 @@ enum class PROGRAM_OPTION: int { LBV_FACTOR, LBV_MASS_LOSS_PRESCRIPTION, + + MALTSEV_FALLBACK, + MASS_LOSS_PRESCRIPTION, MASS_RATIO, @@ -1030,6 +1033,8 @@ const COMPASUnorderedMap PROGRAM_OPTION_LABEL = { { PROGRAM_OPTION::LBV_FACTOR, "LBV_FACTOR" }, { PROGRAM_OPTION::LBV_MASS_LOSS_PRESCRIPTION, "LBV_MASS_LOSS_PRESCRIPTION" }, + + { PROGRAM_OPTION::MALTSEV_FALLBACK, "MALTSEV_FALLBACK" }, { PROGRAM_OPTION::MASS_LOSS_PRESCRIPTION, "MASS_LOSS_PRESCRIPTION" }, { PROGRAM_OPTION::MASS_RATIO, "MASS_RATIO" }, @@ -1575,6 +1580,7 @@ const std::map PROGRAM_OPTION_DETAIL = { { PROGRAM_OPTION::LBV_FACTOR, { TYPENAME::DOUBLE, "PO_LBV_Factor", "-", 24, 15}}, { PROGRAM_OPTION::LBV_MASS_LOSS_PRESCRIPTION, { TYPENAME::INT, "PO_LBV_Mass_Loss_Prscrptn", "-", 4, 1 }}, + { PROGRAM_OPTION::MALTSEV_FALLBACK, { TYPENAME::DOUBLE, "PO_Maltsev_Fallback", "-", 24, 15}}, { PROGRAM_OPTION::MASS_LOSS_PRESCRIPTION, { TYPENAME::INT, "PO_Mass_Loss_Prscrptn", "-", 4, 1 }}, { PROGRAM_OPTION::MASS_RATIO, { TYPENAME::DOUBLE, "PO_Mass_Ratio", "-", 24, 15}}, diff --git a/src/Options.cpp b/src/Options.cpp index d09bd859f..6a4c3c5aa 100644 --- a/src/Options.cpp +++ b/src/Options.cpp @@ -349,6 +349,8 @@ void Options::OptionValues::Initialise() { m_BlackHoleKicksMode.type = BLACK_HOLE_KICKS_MODE::FALLBACK; m_BlackHoleKicksMode.typeString = BLACK_HOLE_KICKS_MODE_LABEL.at(m_BlackHoleKicksMode.type); + m_MaltsevFallback = 0.5; + // Rocket kicks m_RocketKickMagnitude1 = 0.0; m_RocketKickMagnitude2 = 0.0; @@ -1395,6 +1397,12 @@ bool Options::AddOptions(OptionValues *p_Options, po::options_description *p_Opt ("Multiplicitive constant for LBV mass loss (default = " + std::to_string(p_Options->m_LuminousBlueVariableFactor) + ", use 10 for Mennekens & Vanbeveren 2014)").c_str() ) + ( + "maltsev-fallback", + po::value(&p_Options->m_MaltsevFallback)->default_value(p_Options->m_MaltsevFallback), + ("Fallback fraction for Maltsev black holes (ignored otherwise) (default = " + std::to_string(p_Options->m_MaltsevFallback) + ")").c_str() + ) + ( "mass-change-fraction", po::value(&p_Options->m_MassChangeFraction)->default_value(p_Options->m_MassChangeFraction), @@ -2495,9 +2503,11 @@ std::string Options::OptionValues::CheckAndSetOptions() { COMPLAIN_IF(m_LogLevel < 0, "Logging level (--log-level) < 0"); COMPLAIN_IF(m_LuminousBlueVariableFactor < 0.0, "LBV multiplier (--luminous-blue-variable-multiplier) < 0"); + + COMPLAIN_IF(m_MaltsevFallback < 0.0 || m_MaltsevFallback > 1.0, "Maltsev fallback fraction (--maltsev-fallback) must be between 0 and 1, inclusive"); COMPLAIN_IF(m_MassChangeFraction <= 0.0, "Mass change fraction per timestep (--mass-change-fraction) <= 0"); - + COMPLAIN_IF(m_MassRatio <= 0.0 || m_MassRatio > 1.0, "Mass ratio (--mass-ratio) must be greater than 0 and less than or equal to 1"); COMPLAIN_IF(m_MassRatioDistributionMin <= 0.0 || m_MassRatioDistributionMin > 1.0, "Minimum mass ratio (--mass-ratio-min) must be greater than 0 and less than or equal to 1"); @@ -4879,6 +4889,8 @@ COMPAS_VARIABLE Options::OptionValue(const T_ANY_PROPERTY p_Property) const { case PROGRAM_OPTION::LBV_FACTOR : value = LuminousBlueVariableFactor(); break; case PROGRAM_OPTION::LBV_MASS_LOSS_PRESCRIPTION : value = static_cast(LBVMassLossPrescription()); break; + + case PROGRAM_OPTION::MALTSEV_FALLBACK : value = MaltsevFallback(); break; case PROGRAM_OPTION::MASS_LOSS_PRESCRIPTION : value = static_cast(MassLossPrescription()); break; diff --git a/src/Options.h b/src/Options.h index 2c8cb1efd..0d6f70301 100755 --- a/src/Options.h +++ b/src/Options.h @@ -480,6 +480,7 @@ class Options { "logfile-rlof-parameters", "logfile-rlof-parameters-record-types", + "maltsev-fallback", "mass-ratio", "q", "mass-ratio-max", "mass-ratio-min", @@ -851,6 +852,9 @@ class Options { double m_InitialMassFunctionMax; // Maximum mass to generate in Msol double m_InitialMassFunctionPower; // single IMF power law set manually + // Maltsev fallback + double m_MaltsevFallback; // fallback fraction for Maltsev fallback black holes + // Mass ratio double m_MassRatio; // Mass ratio for BSE ENUM_OPT m_MassRatioDistribution; // Which mass ratio distribution @@ -1520,11 +1524,13 @@ class Options { LBV_MASS_LOSS_PRESCRIPTION LBVMassLossPrescription() const { return OPT_VALUE("LBV-mass-loss-prescription", m_LBVMassLossPrescription.type, true); } CORE_MASS_PRESCRIPTION MainSequenceCoreMassPrescription() const { return OPT_VALUE("main-sequence-core-mass-prescription", m_MainSequenceCoreMassPrescription.type, true); } + + double MaltsevFallback() const { return OPT_VALUE("maltsev-fallback", m_MaltsevFallback, true); } double MassChangeFraction() const { return m_CmdLine.optionValues.m_MassChangeFraction; } MASS_LOSS_PRESCRIPTION MassLossPrescription() const { return OPT_VALUE("mass-loss-prescription", m_MassLossPrescription.type, true); } - + double MassRatio() const { return OPT_VALUE("mass-ratio", m_MassRatio, true); } MASS_RATIO_DISTRIBUTION MassRatioDistribution() const { return OPT_VALUE("mass-ratio-distribution", m_MassRatioDistribution.type, true); } double MassRatioDistributionMax() const { return OPT_VALUE("mass-ratio-max", m_MassRatioDistributionMax, true); } diff --git a/src/typedefs.h b/src/typedefs.h index 6f6d8b82d..79babad45 100755 --- a/src/typedefs.h +++ b/src/typedefs.h @@ -1202,6 +1202,11 @@ typedef struct RLOFProperties { double radius1; double radius2; + double teff1; + double teff2; + double lum1; + double lum2; + double starToRocheLobeRadiusRatio1; double starToRocheLobeRadiusRatio2; From 3220e4cd6c9b875ed77075ee636a7b51db41f8bc Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Sat, 10 May 2025 16:04:04 +0200 Subject: [PATCH 06/36] added rlof T and L --- src/LogTypedefs.h | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/src/LogTypedefs.h b/src/LogTypedefs.h index 716e4bd76..db14cd04b 100644 --- a/src/LogTypedefs.h +++ b/src/LogTypedefs.h @@ -513,6 +513,10 @@ enum class BINARY_PROPERTY: int { RLOF_POST_MT_STAR2_MASS, RLOF_POST_MT_STAR1_RADIUS, RLOF_POST_MT_STAR2_RADIUS, + RLOF_POST_MT_STAR1_TEFF, + RLOF_POST_MT_STAR2_TEFF, + RLOF_POST_MT_STAR1_LUM, + RLOF_POST_MT_STAR2_LUM, RLOF_POST_MT_STAR1_RLOF, RLOF_POST_MT_STAR2_RLOF, RLOF_POST_MT_STAR1_STELLAR_TYPE, @@ -527,6 +531,10 @@ enum class BINARY_PROPERTY: int { RLOF_PRE_MT_STAR2_MASS, RLOF_PRE_MT_STAR1_RADIUS, RLOF_PRE_MT_STAR2_RADIUS, + RLOF_PRE_MT_STAR1_TEFF, + RLOF_PRE_MT_STAR2_TEFF, + RLOF_PRE_MT_STAR1_LUM, + RLOF_PRE_MT_STAR2_LUM, RLOF_PRE_MT_STAR1_RLOF, RLOF_PRE_MT_STAR2_RLOF, RLOF_PRE_MT_STAR1_STELLAR_TYPE, @@ -637,6 +645,10 @@ const COMPASUnorderedMap BINARY_PROPERTY_LABEL = { { BINARY_PROPERTY::RLOF_POST_MT_STAR2_MASS, "RLOF_POST_MT_STAR2_MASS" }, { BINARY_PROPERTY::RLOF_POST_MT_STAR1_RADIUS, "RLOF_POST_MT_STAR1_RADIUS" }, { BINARY_PROPERTY::RLOF_POST_MT_STAR2_RADIUS, "RLOF_POST_MT_STAR2_RADIUS" }, + { BINARY_PROPERTY::RLOF_POST_MT_STAR1_TEFF, "RLOF_POST_MT_STAR1_TEFF" }, + { BINARY_PROPERTY::RLOF_POST_MT_STAR2_TEFF, "RLOF_POST_MT_STAR2_TEFF" }, + { BINARY_PROPERTY::RLOF_POST_MT_STAR1_LUM, "RLOF_POST_MT_STAR1_LUM" }, + { BINARY_PROPERTY::RLOF_POST_MT_STAR2_LUM, "RLOF_POST_MT_STAR2_LUM" }, { BINARY_PROPERTY::RLOF_POST_MT_STAR1_RLOF, "RLOF_POST_MT_STAR1_RLOF" }, { BINARY_PROPERTY::RLOF_POST_MT_STAR2_RLOF, "RLOF_POST_MT_STAR2_RLOF" }, { BINARY_PROPERTY::RLOF_POST_MT_STAR1_STELLAR_TYPE, "RLOF_POST_MT_STAR1_STELLAR_TYPE" }, @@ -651,6 +663,10 @@ const COMPASUnorderedMap BINARY_PROPERTY_LABEL = { { BINARY_PROPERTY::RLOF_PRE_MT_STAR2_MASS, "RLOF_PRE_MT_STAR2_MASS" }, { BINARY_PROPERTY::RLOF_PRE_MT_STAR1_RADIUS, "RLOF_PRE_MT_STAR1_RADIUS" }, { BINARY_PROPERTY::RLOF_PRE_MT_STAR2_RADIUS, "RLOF_PRE_MT_STAR2_RADIUS" }, + { BINARY_PROPERTY::RLOF_PRE_MT_STAR1_TEFF, "RLOF_PRE_MT_STAR1_TEFF" }, + { BINARY_PROPERTY::RLOF_PRE_MT_STAR2_TEFF, "RLOF_PRE_MT_STAR2_TEFF" }, + { BINARY_PROPERTY::RLOF_PRE_MT_STAR1_LUM, "RLOF_PRE_MT_STAR1_LUM" }, + { BINARY_PROPERTY::RLOF_PRE_MT_STAR2_LUM, "RLOF_PRE_MT_STAR2_LUM" }, { BINARY_PROPERTY::RLOF_PRE_MT_STAR1_RLOF, "RLOF_PRE_MT_STAR1_RLOF" }, { BINARY_PROPERTY::RLOF_PRE_MT_STAR2_RLOF, "RLOF_PRE_MT_STAR2_RLOF" }, { BINARY_PROPERTY::RLOF_PRE_MT_STAR1_STELLAR_TYPE, "RLOF_PRE_MT_STAR1_STELLAR_TYPE" }, @@ -1412,6 +1428,10 @@ const std::map BINARY_PROPERTY_DETAIL = { { BINARY_PROPERTY::RLOF_POST_MT_STAR2_MASS, { TYPENAME::DOUBLE, "Mass(2)>MT", "Msol", 24, 15}}, { BINARY_PROPERTY::RLOF_POST_MT_STAR1_RADIUS, { TYPENAME::DOUBLE, "Radius(1)>MT", "Rsol", 24, 15}}, { BINARY_PROPERTY::RLOF_POST_MT_STAR2_RADIUS, { TYPENAME::DOUBLE, "Radius(2)>MT", "Rsol", 24, 15}}, + { BINARY_PROPERTY::RLOF_POST_MT_STAR1_TEFF, { TYPENAME::DOUBLE, "Teff(1)>MT", "K?", 24, 15}}, + { BINARY_PROPERTY::RLOF_POST_MT_STAR2_TEFF, { TYPENAME::DOUBLE, "Teff(2)>MT", "K?", 24, 15}}, + { BINARY_PROPERTY::RLOF_POST_MT_STAR1_LUM, { TYPENAME::DOUBLE, "Lum(1)>MT", "Lsol", 24, 15}}, + { BINARY_PROPERTY::RLOF_POST_MT_STAR2_LUM, { TYPENAME::DOUBLE, "Lum(2)>MT", "Lsol", 24, 15}}, { BINARY_PROPERTY::RLOF_POST_MT_STAR1_RLOF, { TYPENAME::BOOL, "RLOF(1)>MT", "State", 0, 0 }}, { BINARY_PROPERTY::RLOF_POST_MT_STAR2_RLOF, { TYPENAME::BOOL, "RLOF(2)>MT", "State", 0, 0 }}, { BINARY_PROPERTY::RLOF_POST_MT_STAR1_STELLAR_TYPE, { TYPENAME::STELLAR_TYPE, "Stellar_Type(1)>MT", "-", 4, 1 }}, @@ -1426,6 +1446,10 @@ const std::map BINARY_PROPERTY_DETAIL = { { BINARY_PROPERTY::RLOF_PRE_MT_STAR2_MASS, { TYPENAME::DOUBLE, "Mass(2) Date: Sun, 11 May 2025 01:20:31 +0200 Subject: [PATCH 07/36] added pre and post RLOF values for Teff, L in basebinarystar --- src/BaseBinaryStar.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/BaseBinaryStar.cpp b/src/BaseBinaryStar.cpp index 4e00738b9..4d3971f47 100644 --- a/src/BaseBinaryStar.cpp +++ b/src/BaseBinaryStar.cpp @@ -567,6 +567,10 @@ COMPAS_VARIABLE BaseBinaryStar::BinaryPropertyValue(const T_ANY_PROPERTY p_Prope case BINARY_PROPERTY::RLOF_POST_MT_STAR2_MASS: value = RLOFDetails().propsPostMT->mass2; break; case BINARY_PROPERTY::RLOF_POST_MT_STAR1_RADIUS: value = RLOFDetails().propsPostMT->radius1; break; case BINARY_PROPERTY::RLOF_POST_MT_STAR2_RADIUS: value = RLOFDetails().propsPostMT->radius2; break; + case BINARY_PROPERTY::RLOF_POST_MT_STAR1_TEFF: value = RLOFDetails().propsPostMT->teff1; break; + case BINARY_PROPERTY::RLOF_POST_MT_STAR2_TEFF: value = RLOFDetails().propsPostMT->teff2; break; + case BINARY_PROPERTY::RLOF_POST_MT_STAR1_LUM: value = RLOFDetails().propsPostMT->lum1; break; + case BINARY_PROPERTY::RLOF_POST_MT_STAR2_LUM: value = RLOFDetails().propsPostMT->lum2; break; case BINARY_PROPERTY::RLOF_POST_MT_STAR1_RLOF: value = RLOFDetails().propsPostMT->isRLOF1; break; case BINARY_PROPERTY::RLOF_POST_MT_STAR2_RLOF: value = RLOFDetails().propsPostMT->isRLOF2; break; case BINARY_PROPERTY::RLOF_POST_MT_STAR1_STELLAR_TYPE: value = RLOFDetails().propsPostMT->stellarType1; break; @@ -581,6 +585,10 @@ COMPAS_VARIABLE BaseBinaryStar::BinaryPropertyValue(const T_ANY_PROPERTY p_Prope case BINARY_PROPERTY::RLOF_PRE_MT_STAR2_MASS: value = RLOFDetails().propsPreMT->mass2; break; case BINARY_PROPERTY::RLOF_PRE_MT_STAR1_RADIUS: value = RLOFDetails().propsPreMT->radius1; break; case BINARY_PROPERTY::RLOF_PRE_MT_STAR2_RADIUS: value = RLOFDetails().propsPreMT->radius2; break; + case BINARY_PROPERTY::RLOF_PRE_MT_STAR1_TEFF: value = RLOFDetails().propsPreMT->teff1; break; + case BINARY_PROPERTY::RLOF_PRE_MT_STAR2_TEFF: value = RLOFDetails().propsPreMT->teff2; break; + case BINARY_PROPERTY::RLOF_PRE_MT_STAR1_LUM: value = RLOFDetails().propsPreMT->lum1; break; + case BINARY_PROPERTY::RLOF_PRE_MT_STAR2_LUM: value = RLOFDetails().propsPreMT->lum2; break; case BINARY_PROPERTY::RLOF_PRE_MT_STAR1_RLOF: value = RLOFDetails().propsPreMT->isRLOF1; break; case BINARY_PROPERTY::RLOF_PRE_MT_STAR2_RLOF: value = RLOFDetails().propsPreMT->isRLOF2; break; case BINARY_PROPERTY::RLOF_PRE_MT_STAR1_STELLAR_TYPE: value = RLOFDetails().propsPreMT->stellarType1; break; From cf543111690782f3886f7bc0c0662315105cc10e Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Wed, 21 May 2025 10:22:44 +0200 Subject: [PATCH 08/36] cleaned up Maltsev function --- src/GiantBranch.cpp | 137 ++++++++++++++++++++++---------------------- 1 file changed, 70 insertions(+), 67 deletions(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index 91bd5b143..fcd0c368b 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1314,79 +1314,82 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, MT_CASE massTransferCase = MT_CASE::OTHER; double log10Z = m_Log10Metallicity - LOG10_ZSOL; // log_{10} (Z/Zsol), for convenience double M1, M2, M3; + double remnantMass; - if (utils::Compare(p_COCoreMass, MALTSEV2024_MMIN) < 0) // NS formation regardless of metallicity and MT history - return 1.35; //CalculateRemnantNSMassMullerMandel(p_COCoreMass, p_HeCoreMass); - - if (utils::Compare(p_COCoreMass, MALTSEV2024_MMAX) > 0) // BH formation regardless of metallicity and MT history - return p_HeCoreMass; - - // determine MT history - this will tell us which Schneider MT case prescription should be used - if (mtHist.size() == 0) { // no history of MT - effectively single star - massTransferCase = MT_CASE::NONE; + if (utils::Compare(p_COCoreMass, MALTSEV2024_MMIN) < 0) { // NS formation regardless of metallicity and MT history + remnantMass = 1.35; //CalculateRemnantNSMassMullerMandel(p_COCoreMass, p_HeCoreMass); } - else { // star was MT donor at least once - // determine MT_CASE of first MT event - STELLAR_TYPE stellarTypeAtFirstDonation = mtHist[0]; // stellar type at first MT event (as donor) - BaseStar* newStar = stellarUtils::NewStar(stellarTypeAtFirstDonation); // create new (empty) star of correct stellar type - massTransferCase = newStar->DetermineMassTransferTypeAsDonor(); // get MT type as donor - delete newStar; newStar = nullptr; // return the memory allocated for the new star + else if (utils::Compare(p_COCoreMass, MALTSEV2024_MMAX) > 0) { // BH formation regardless of metallicity and MT history + remnantMass = p_HeCoreMass; } + else { // Determine MT history - this will tell us which Schneider MT case prescription should be used + if (mtHist.size() == 0) { // no history of MT - effectively single star + massTransferCase = MT_CASE::NONE; + } + else { // star was MT donor at least once + // determine MT_CASE of first MT event + STELLAR_TYPE stellarTypeAtFirstDonation = mtHist[0]; // stellar type at first MT event (as donor) + BaseStar* newStar = stellarUtils::NewStar(stellarTypeAtFirstDonation); // create new (empty) star of correct stellar type + massTransferCase = newStar->DetermineMassTransferTypeAsDonor(); // get MT type as donor + delete newStar; newStar = nullptr; // return the memory allocated for the new star + } - // apply the appropriate remnant mass prescription for the chosen MT case - switch (massTransferCase) { // which MT_CASE? - - case MT_CASE::NONE: // no history of MT - case MT_CASE::OTHER: // if MT happens from naked He stars, WDs, etc., assume that the core properties are not affected - - M1 = std::min(std::max(MALTSEV2024_M1S + (MALTSEV2024_M1S - MALTSEV2024_M1SZ01) * log10Z, MALTSEV2024_M1SZ01), MALTSEV2024_M1S); - M2 = std::min(std::max(MALTSEV2024_M2S + (MALTSEV2024_M2S - MALTSEV2024_M2SZ01) * log10Z, MALTSEV2024_M2SZ01), MALTSEV2024_M2S); - M3 = std::min(std::max(MALTSEV2024_M3S + (MALTSEV2024_M3S - MALTSEV2024_M3SZ01) * log10Z, MALTSEV2024_M3SZ01), MALTSEV2024_M3S); - break; - - case MT_CASE::A: // case A MT - M1 = std::min(std::max(MALTSEV2024_M1A + (MALTSEV2024_M1A - MALTSEV2024_M1AZ01) * log10Z, MALTSEV2024_M1AZ01), MALTSEV2024_M1A); - M2 = std::min(std::max(MALTSEV2024_M2A + (MALTSEV2024_M2A - MALTSEV2024_M2AZ01) * log10Z, MALTSEV2024_M2AZ01), MALTSEV2024_M2A); - M3 = std::min(std::max(MALTSEV2024_M3A + (MALTSEV2024_M3A - MALTSEV2024_M3AZ01) * log10Z, MALTSEV2024_M3AZ01), MALTSEV2024_M3A); - break; - - case MT_CASE::B: // case B MT - M1 = std::min(std::max(MALTSEV2024_M1B + (MALTSEV2024_M1B - MALTSEV2024_M1BZ01) * log10Z, MALTSEV2024_M1BZ01), MALTSEV2024_M1B); - M2 = std::min(std::max(MALTSEV2024_M2B + (MALTSEV2024_M2B - MALTSEV2024_M2BZ01) * log10Z, MALTSEV2024_M2BZ01), MALTSEV2024_M2B); - M3 = std::min(std::max(MALTSEV2024_M3B + (MALTSEV2024_M3B - MALTSEV2024_M3BZ01) * log10Z, MALTSEV2024_M3BZ01), MALTSEV2024_M3B); - break; - - case MT_CASE::C: // case C MT - M1 = std::min(std::max(MALTSEV2024_M1C + (MALTSEV2024_M1C - MALTSEV2024_M1CZ01) * log10Z, MALTSEV2024_M1CZ01), MALTSEV2024_M1C); - M2 = std::min(std::max(MALTSEV2024_M2C + (MALTSEV2024_M2C - MALTSEV2024_M2CZ01) * log10Z, MALTSEV2024_M2CZ01), MALTSEV2024_M2C); - M3 = std::min(std::max(MALTSEV2024_M3C + (MALTSEV2024_M3C - MALTSEV2024_M3CZ01) * log10Z, MALTSEV2024_M3CZ01), MALTSEV2024_M3C); - break; - - default: // unknown MT_CASE - // the only way this can happen is if someone added an MT_CASE - // and it isn't accounted for in this code. We should not default here, with or without a warning. - // We are here because DetermineMassTransferTypeAsDonor() returned an MT_CASE this code doesn't - // account for, and that should be flagged as an error and result in termination of the evolution - // of the star or binary. - // The correct fix for this is to add code for the missing MT_CASE or, if the missing MT_CASE is - // incorrect/superfluous, remove it from the possible MT_CASE values. - - THROW_ERROR(ERROR::UNKNOWN_MT_CASE); // throw error - } - - if( utils::Compare(p_COCoreMass, M3) >=0 || (utils::Compare(p_COCoreMass, M1) >= 0 && utils::Compare(p_COCoreMass, M2) <= 0) ) // Complete fallback into BH - { - return p_HeCoreMass; + // apply the appropriate remnant mass prescription for the chosen MT case + switch (massTransferCase) { // which MT_CASE? + + case MT_CASE::NONE: // no history of MT + case MT_CASE::OTHER: // if MT happens from naked He stars, WDs, etc., assume that the core properties are not affected + + M1 = std::min(std::max(MALTSEV2024_M1S + (MALTSEV2024_M1S - MALTSEV2024_M1SZ01) * log10Z, MALTSEV2024_M1SZ01), MALTSEV2024_M1S); + M2 = std::min(std::max(MALTSEV2024_M2S + (MALTSEV2024_M2S - MALTSEV2024_M2SZ01) * log10Z, MALTSEV2024_M2SZ01), MALTSEV2024_M2S); + M3 = std::min(std::max(MALTSEV2024_M3S + (MALTSEV2024_M3S - MALTSEV2024_M3SZ01) * log10Z, MALTSEV2024_M3SZ01), MALTSEV2024_M3S); + break; + + case MT_CASE::A: // case A MT + M1 = std::min(std::max(MALTSEV2024_M1A + (MALTSEV2024_M1A - MALTSEV2024_M1AZ01) * log10Z, MALTSEV2024_M1AZ01), MALTSEV2024_M1A); + M2 = std::min(std::max(MALTSEV2024_M2A + (MALTSEV2024_M2A - MALTSEV2024_M2AZ01) * log10Z, MALTSEV2024_M2AZ01), MALTSEV2024_M2A); + M3 = std::min(std::max(MALTSEV2024_M3A + (MALTSEV2024_M3A - MALTSEV2024_M3AZ01) * log10Z, MALTSEV2024_M3AZ01), MALTSEV2024_M3A); + break; + + case MT_CASE::B: // case B MT + M1 = std::min(std::max(MALTSEV2024_M1B + (MALTSEV2024_M1B - MALTSEV2024_M1BZ01) * log10Z, MALTSEV2024_M1BZ01), MALTSEV2024_M1B); + M2 = std::min(std::max(MALTSEV2024_M2B + (MALTSEV2024_M2B - MALTSEV2024_M2BZ01) * log10Z, MALTSEV2024_M2BZ01), MALTSEV2024_M2B); + M3 = std::min(std::max(MALTSEV2024_M3B + (MALTSEV2024_M3B - MALTSEV2024_M3BZ01) * log10Z, MALTSEV2024_M3BZ01), MALTSEV2024_M3B); + break; + + case MT_CASE::C: // case C MT + M1 = std::min(std::max(MALTSEV2024_M1C + (MALTSEV2024_M1C - MALTSEV2024_M1CZ01) * log10Z, MALTSEV2024_M1CZ01), MALTSEV2024_M1C); + M2 = std::min(std::max(MALTSEV2024_M2C + (MALTSEV2024_M2C - MALTSEV2024_M2CZ01) * log10Z, MALTSEV2024_M2CZ01), MALTSEV2024_M2C); + M3 = std::min(std::max(MALTSEV2024_M3C + (MALTSEV2024_M3C - MALTSEV2024_M3CZ01) * log10Z, MALTSEV2024_M3CZ01), MALTSEV2024_M3C); + break; + + default: // unknown MT_CASE + // the only way this can happen is if someone added an MT_CASE + // and it isn't accounted for in this code. We should not default here, with or without a warning. + // We are here because DetermineMassTransferTypeAsDonor() returned an MT_CASE this code doesn't + // account for, and that should be flagged as an error and result in termination of the evolution + // of the star or binary. + // The correct fix for this is to add code for the missing MT_CASE or, if the missing MT_CASE is + // incorrect/superfluous, remove it from the possible MT_CASE values. + + THROW_ERROR(ERROR::UNKNOWN_MT_CASE); // throw error } - else if ( utils::Compare(p_COCoreMass, M2) > 0 && utils::Compare(p_COCoreMass, M3) < 0 && utils::Compare(RAND->Random(0, 1), 0.1) <= 0 ) // Partial fallback BH formation - { - // add fallback back on - m_SupernovaDetails.fallbackFraction = OPTIONS->MaltsevFallback(); - double mhe = m_SupernovaDetails.HeCoreMassAtCOFormation; - double mns = 1.44; - return 1.44 + (mhe - mns) *m_SupernovaDetails.fallbackFraction; + + if( utils::Compare(p_COCoreMass, M3) >=0 || (utils::Compare(p_COCoreMass, M1) >= 0 && utils::Compare(p_COCoreMass, M2) <= 0) ) { // Complete fallback into BH + remnantMass = p_HeCoreMass; } - return 1.40; // slightly lower mass NS - just to distinguish it... + else if ( utils::Compare(p_COCoreMass, M2) > 0 && utils::Compare(p_COCoreMass, M3) < 0 && utils::Compare(RAND->Random(0, 1), 0.1) <= 0 ) { // Partial fallback BH formation + // add fallback back on + m_SupernovaDetails.fallbackFraction = OPTIONS->MaltsevFallback(); + double mhe = m_SupernovaDetails.HeCoreMassAtCOFormation; + double mns = 1.44; + remnantMass = mns + (mhe - mns) *m_SupernovaDetails.fallbackFraction; + } + else { + remnantMass = 1.40; // slightly lower mass NS - just to distinguish it... + } + } + return remnantMass; } From b8b621f15a40193cd7304557ab0eab1c2ac90ff2 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Sun, 25 May 2025 18:28:51 +0200 Subject: [PATCH 09/36] fixed fallback setup for Maltsev BH kicks --- src/GiantBranch.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index fcd0c368b..726df50e6 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1317,9 +1317,11 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, double remnantMass; if (utils::Compare(p_COCoreMass, MALTSEV2024_MMIN) < 0) { // NS formation regardless of metallicity and MT history + m_SupernovaDetails.fallbackFraction = 0; remnantMass = 1.35; //CalculateRemnantNSMassMullerMandel(p_COCoreMass, p_HeCoreMass); } else if (utils::Compare(p_COCoreMass, MALTSEV2024_MMAX) > 0) { // BH formation regardless of metallicity and MT history + m_SupernovaDetails.fallbackFraction = 1; remnantMass = p_HeCoreMass; } else { // Determine MT history - this will tell us which Schneider MT case prescription should be used @@ -1377,6 +1379,7 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, if( utils::Compare(p_COCoreMass, M3) >=0 || (utils::Compare(p_COCoreMass, M1) >= 0 && utils::Compare(p_COCoreMass, M2) <= 0) ) { // Complete fallback into BH remnantMass = p_HeCoreMass; + m_SupernovaDetails.fallbackFraction = 1; } else if ( utils::Compare(p_COCoreMass, M2) > 0 && utils::Compare(p_COCoreMass, M3) < 0 && utils::Compare(RAND->Random(0, 1), 0.1) <= 0 ) { // Partial fallback BH formation // add fallback back on @@ -1386,6 +1389,7 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, remnantMass = mns + (mhe - mns) *m_SupernovaDetails.fallbackFraction; } else { + m_SupernovaDetails.fallbackFraction = 0; remnantMass = 1.40; // slightly lower mass NS - just to distinguish it... } } From 3c6a8cdffff863424728823d8b2dabffed2831e5 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Wed, 11 Jun 2025 10:38:43 +0200 Subject: [PATCH 10/36] modified Kiril options --- src/ErrorCatalog.h | 2 ++ src/Errors.cpp | 3 +-- src/GiantBranch.cpp | 49 +++++++++++++++++++++++++++++++++------------ src/LogTypedefs.h | 3 +++ src/Options.cpp | 16 ++++++++++++++- src/Options.h | 5 ++++- src/typedefs.h | 8 ++++++++ 7 files changed, 69 insertions(+), 17 deletions(-) diff --git a/src/ErrorCatalog.h b/src/ErrorCatalog.h index 9c90dfd2c..fea6e5ce4 100644 --- a/src/ErrorCatalog.h +++ b/src/ErrorCatalog.h @@ -166,6 +166,7 @@ enum class ERROR: int { UNKNOWN_KICK_MAGNITUDE_DISTRIBUTION, // unknown kick magnitude distribution UNKNOWN_LOGFILE, // unknown log file UNKNOWN_LBV_MASS_LOSS_PRESCRIPTION, // unknown LBV mass loss prescription + UNKNOWN_MALTSEV_MODE, // unknown maltsev mode UNKNOWN_MT_ACCRETION_EFFICIENCY_PRESCRIPTION, // unknown mass transfer accretion efficiency prescription UNKNOWN_MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION, // unknown mass transfer angular momentum loss prescription UNKNOWN_MASS_LOSS_PRESCRIPTION, // unknown mass loss prescription @@ -342,6 +343,7 @@ const COMPASUnorderedMap> ERROR_CATA { ERROR::UNKNOWN_KICK_MAGNITUDE_DISTRIBUTION, { ERROR_SCOPE::ALWAYS, "Unknown kick magnitude distribution" }}, { ERROR::UNKNOWN_LBV_MASS_LOSS_PRESCRIPTION, { ERROR_SCOPE::ALWAYS, "Unknown LBV mass loss prescription" }}, { ERROR::UNKNOWN_LOGFILE, { ERROR_SCOPE::ALWAYS, "Unknown log file" }}, + { ERROR::UNKNOWN_MALTSEV_MODE, { ERROR_SCOPE::ALWAYS, "Unknown Maltsev remnant mass mode" }}, { ERROR::UNKNOWN_MT_CASE, { ERROR_SCOPE::ALWAYS, "Unknown mass transfer case" }}, { ERROR::UNKNOWN_MT_ACCRETION_EFFICIENCY_PRESCRIPTION, { ERROR_SCOPE::ALWAYS, "Unknown mass transfer accretion efficiency prescription" }}, { ERROR::UNKNOWN_MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION, { ERROR_SCOPE::ALWAYS, "Unknown mass transfer angular momentum loss prescription" }}, diff --git a/src/Errors.cpp b/src/Errors.cpp index f9dd3cdd5..397e5e079 100755 --- a/src/Errors.cpp +++ b/src/Errors.cpp @@ -1,5 +1,4 @@ -/* - * Class Errors +/* * Class Errors * * Provides global error handling functionality. * diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index ac3d2f250..89cd0a9fc 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1316,6 +1316,30 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, remnantMass = p_HeCoreMass; } else { // Determine MT history - this will tell us which Schneider MT case prescription should be used + + // RTW add in the code here for the different cases + double log10Z_bounded; + switch (OPTIONS->MaltsevMode()) { // TODO + + case MALTSEV_MODE::OPTIMISTIC: // TODO + log10Z_bounded = log10Z; + case MALTSEV_MODE::BALANCED: // TODO + log10Z_bounded = std::min(std::max(log10Z, LOG10_ZSOL/50), LOG10_ZSOL); + case MALTSEV_MODE::PESSIMISTIC: // TODO + log10Z_bounded = std::min(std::max(log10Z, LOG10_ZSOL/10), LOG10_ZSOL); + default: // unknown MT_CASE + // TODO: rewrite this + // the only way this can happen is if someone added an MT_CASE + // and it isn't accounted for in this code. We should not default here, with or without a warning. + // We are here because DetermineMassTransferTypeAsDonor() returned an MT_CASE this code doesn't + // account for, and that should be flagged as an error and result in termination of the evolution + // of the star or binary. + // The correct fix for this is to add code for the missing MT_CASE or, if the missing MT_CASE is + // incorrect/superfluous, remove it from the possible MT_CASE values. + + THROW_ERROR(ERROR::UNKNOWN_MALTSEV_MODE); // throw error + } + if (mtHist.size() == 0) { // no history of MT - effectively single star massTransferCase = MT_CASE::NONE; } @@ -1332,28 +1356,27 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, case MT_CASE::NONE: // no history of MT case MT_CASE::OTHER: // if MT happens from naked He stars, WDs, etc., assume that the core properties are not affected - - M1 = std::min(std::max(MALTSEV2024_M1S + (MALTSEV2024_M1S - MALTSEV2024_M1SZ01) * log10Z, MALTSEV2024_M1SZ01), MALTSEV2024_M1S); - M2 = std::min(std::max(MALTSEV2024_M2S + (MALTSEV2024_M2S - MALTSEV2024_M2SZ01) * log10Z, MALTSEV2024_M2SZ01), MALTSEV2024_M2S); - M3 = std::min(std::max(MALTSEV2024_M3S + (MALTSEV2024_M3S - MALTSEV2024_M3SZ01) * log10Z, MALTSEV2024_M3SZ01), MALTSEV2024_M3S); + M1 = MALTSEV2024_M1S + (MALTSEV2024_M1S - MALTSEV2024_M1SZ01) * log10Z_bounded; + M2 = MALTSEV2024_M2S + (MALTSEV2024_M2S - MALTSEV2024_M2SZ01) * log10Z_bounded; + M3 = MALTSEV2024_M3S + (MALTSEV2024_M3S - MALTSEV2024_M3SZ01) * log10Z_bounded; break; case MT_CASE::A: // case A MT - M1 = std::min(std::max(MALTSEV2024_M1A + (MALTSEV2024_M1A - MALTSEV2024_M1AZ01) * log10Z, MALTSEV2024_M1AZ01), MALTSEV2024_M1A); - M2 = std::min(std::max(MALTSEV2024_M2A + (MALTSEV2024_M2A - MALTSEV2024_M2AZ01) * log10Z, MALTSEV2024_M2AZ01), MALTSEV2024_M2A); - M3 = std::min(std::max(MALTSEV2024_M3A + (MALTSEV2024_M3A - MALTSEV2024_M3AZ01) * log10Z, MALTSEV2024_M3AZ01), MALTSEV2024_M3A); + M1 = MALTSEV2024_M1A + (MALTSEV2024_M1A - MALTSEV2024_M1AZ01) * log10Z_bounded; + M2 = MALTSEV2024_M2A + (MALTSEV2024_M2A - MALTSEV2024_M2AZ01) * log10Z_bounded; + M3 = MALTSEV2024_M3A + (MALTSEV2024_M3A - MALTSEV2024_M3AZ01) * log10Z_bounded; break; case MT_CASE::B: // case B MT - M1 = std::min(std::max(MALTSEV2024_M1B + (MALTSEV2024_M1B - MALTSEV2024_M1BZ01) * log10Z, MALTSEV2024_M1BZ01), MALTSEV2024_M1B); - M2 = std::min(std::max(MALTSEV2024_M2B + (MALTSEV2024_M2B - MALTSEV2024_M2BZ01) * log10Z, MALTSEV2024_M2BZ01), MALTSEV2024_M2B); - M3 = std::min(std::max(MALTSEV2024_M3B + (MALTSEV2024_M3B - MALTSEV2024_M3BZ01) * log10Z, MALTSEV2024_M3BZ01), MALTSEV2024_M3B); + M1 = MALTSEV2024_M1B + (MALTSEV2024_M1B - MALTSEV2024_M1BZ01) * log10Z_bounded; + M2 = MALTSEV2024_M2B + (MALTSEV2024_M2B - MALTSEV2024_M2BZ01) * log10Z_bounded; + M3 = MALTSEV2024_M3B + (MALTSEV2024_M3B - MALTSEV2024_M3BZ01) * log10Z_bounded; break; case MT_CASE::C: // case C MT - M1 = std::min(std::max(MALTSEV2024_M1C + (MALTSEV2024_M1C - MALTSEV2024_M1CZ01) * log10Z, MALTSEV2024_M1CZ01), MALTSEV2024_M1C); - M2 = std::min(std::max(MALTSEV2024_M2C + (MALTSEV2024_M2C - MALTSEV2024_M2CZ01) * log10Z, MALTSEV2024_M2CZ01), MALTSEV2024_M2C); - M3 = std::min(std::max(MALTSEV2024_M3C + (MALTSEV2024_M3C - MALTSEV2024_M3CZ01) * log10Z, MALTSEV2024_M3CZ01), MALTSEV2024_M3C); + M1 = MALTSEV2024_M1C + (MALTSEV2024_M1C - MALTSEV2024_M1CZ01) * log10Z_bounded; + M2 = MALTSEV2024_M2C + (MALTSEV2024_M2C - MALTSEV2024_M2CZ01) * log10Z_bounded; + M3 = MALTSEV2024_M3C + (MALTSEV2024_M3C - MALTSEV2024_M3CZ01) * log10Z_bounded; break; default: // unknown MT_CASE diff --git a/src/LogTypedefs.h b/src/LogTypedefs.h index f25bb48d5..ebbfddfea 100644 --- a/src/LogTypedefs.h +++ b/src/LogTypedefs.h @@ -882,6 +882,7 @@ enum class PROGRAM_OPTION: int { LBV_MASS_LOSS_PRESCRIPTION, MALTSEV_FALLBACK, + MALTSEV_MODE, MASS_LOSS_PRESCRIPTION, @@ -1109,6 +1110,7 @@ const COMPASUnorderedMap PROGRAM_OPTION_LABEL = { { PROGRAM_OPTION::LBV_MASS_LOSS_PRESCRIPTION, "LBV_MASS_LOSS_PRESCRIPTION" }, { PROGRAM_OPTION::MALTSEV_FALLBACK, "MALTSEV_FALLBACK" }, + { PROGRAM_OPTION::MALTSEV_MODE, "MALTSEV_MODE" }, { PROGRAM_OPTION::MASS_LOSS_PRESCRIPTION, "MASS_LOSS_PRESCRIPTION" }, { PROGRAM_OPTION::MASS_RATIO, "MASS_RATIO" }, @@ -1692,6 +1694,7 @@ const std::map PROGRAM_OPTION_DETAIL = { { PROGRAM_OPTION::LBV_MASS_LOSS_PRESCRIPTION, { TYPENAME::INT, "PO_LBV_Mass_Loss_Prscrptn", "-", 4, 1 }}, { PROGRAM_OPTION::MALTSEV_FALLBACK, { TYPENAME::DOUBLE, "PO_Maltsev_Fallback", "-", 24, 15}}, + { PROGRAM_OPTION::MALTSEV_MODE, { TYPENAME::INT, "PO_Maltsev_Mode", "-", 4, 1 }}, { PROGRAM_OPTION::MASS_LOSS_PRESCRIPTION, { TYPENAME::INT, "PO_Mass_Loss_Prscrptn", "-", 4, 1 }}, { PROGRAM_OPTION::MASS_RATIO, { TYPENAME::DOUBLE, "PO_Mass_Ratio", "-", 24, 15}}, diff --git a/src/Options.cpp b/src/Options.cpp index 45d9f9678..d19bdde4d 100644 --- a/src/Options.cpp +++ b/src/Options.cpp @@ -359,6 +359,8 @@ void Options::OptionValues::Initialise() { m_BlackHoleKicksMode.typeString = BLACK_HOLE_KICKS_MODE_LABEL.at(m_BlackHoleKicksMode.type); m_MaltsevFallback = 0.5; + m_MaltsevMode.type = MALTSEV_MODE::BALANCED; + m_MaltsevMode.typeString = MALTSEV_MODE_LABEL.at(m_MaltsevMode.type); // Rocket kicks m_RocketKickMagnitude1 = 0.0; @@ -1947,6 +1949,11 @@ bool Options::AddOptions(OptionValues *p_Options, po::options_description *p_Opt ("Main Sequence core mass prescription (" + AllowedOptionValuesFormatted("main-sequence-core-mass-prescription") + ", default = '" + p_Options->m_MainSequenceCoreMassPrescription.typeString + "')").c_str() ) + ( + "maltsev-mode", + po::value(&p_Options->m_MaltsevMode.typeString)->default_value(p_Options->m_MaltsevMode.typeString), + ("Maltsev mode (" + AllowedOptionValuesFormatted("maltsev-mode") + ", default = '" + p_Options->m_MaltsevMode.typeString + "')").c_str() + ) ( "mass-loss-prescription", po::value(&p_Options->m_MassLossPrescription.typeString)->default_value(p_Options->m_MassLossPrescription.typeString), @@ -2400,6 +2407,11 @@ std::string Options::OptionValues::CheckAndSetOptions() { COMPLAIN_IF(!found, "Unknown Main Sequence Core Mass Prescription"); } + if (!DEFAULTED("maltsev-mode")) { // mass loss prescription + std::tie(found, m_MaltsevMode.type) = utils::GetMapKey(m_MaltsevMode.typeString, MALTSEV_MODE_LABEL, m_MaltsevMode.type); + COMPLAIN_IF(!found, "Unknown Mass Loss Prescription"); + } + if (!DEFAULTED("mass-loss-prescription")) { // mass loss prescription std::tie(found, m_MassLossPrescription.type) = utils::GetMapKey(m_MassLossPrescription.typeString, MASS_LOSS_PRESCRIPTION_LABEL, m_MassLossPrescription.type); COMPLAIN_IF(!found, "Unknown Mass Loss Prescription"); @@ -2798,6 +2810,7 @@ STR_VECTOR Options::AllowedOptionValues(const std::string p_OptionString) { case _("logfile-type") : POPULATE_RET(LOGFILETYPELabel); break; case _("LBV-mass-loss-prescription") : POPULATE_RET(LBV_MASS_LOSS_PRESCRIPTION_LABEL); break; case _("main-sequence-core-mass-prescription") : POPULATE_RET(CORE_MASS_PRESCRIPTION_LABEL); break; + case _("maltsev-mode") : POPULATE_RET(MALTSEV_MODE_LABEL); break; case _("mass-loss-prescription") : POPULATE_RET(MASS_LOSS_PRESCRIPTION_LABEL); break; case _("mass-ratio-distribution") : POPULATE_RET(MASS_RATIO_DISTRIBUTION_LABEL); break; case _("mass-transfer-accretion-efficiency-prescription") : POPULATE_RET(MT_ACCRETION_EFFICIENCY_PRESCRIPTION_LABEL); break; @@ -4968,7 +4981,8 @@ COMPAS_VARIABLE Options::OptionValue(const T_ANY_PROPERTY p_Property) const { case PROGRAM_OPTION::LBV_MASS_LOSS_PRESCRIPTION : value = static_cast(LBVMassLossPrescription()); break; case PROGRAM_OPTION::MALTSEV_FALLBACK : value = MaltsevFallback(); break; - + case PROGRAM_OPTION::MALTSEV_MODE : value = static_cast(MaltsevMode()); break; + case PROGRAM_OPTION::MASS_LOSS_PRESCRIPTION : value = static_cast(MassLossPrescription()); break; case PROGRAM_OPTION::MASS_RATIO : value = MassRatio(); break; diff --git a/src/Options.h b/src/Options.h index a61b7529a..a68e6d041 100755 --- a/src/Options.h +++ b/src/Options.h @@ -630,6 +630,7 @@ class Options { "logfile-type", "main-sequence-core-mass-prescription", + "maltsev-mode", "mass-change-fraction", "mass-loss-prescription", "mass-ratio-distribution", @@ -875,8 +876,9 @@ class Options { double m_InitialMassFunctionMax; // Maximum mass to generate in Msol double m_InitialMassFunctionPower; // single IMF power law set manually - // Maltsev fallback + // Maltsev remnant mass model double m_MaltsevFallback; // fallback fraction for Maltsev fallback black holes + ENUM_OPT m_MaltsevMode; // Maltsev remnant mass mode (which variant of the prescription) // Mass ratio double m_MassRatio; // Mass ratio for BSE @@ -1560,6 +1562,7 @@ class Options { CORE_MASS_PRESCRIPTION MainSequenceCoreMassPrescription() const { return OPT_VALUE("main-sequence-core-mass-prescription", m_MainSequenceCoreMassPrescription.type, true); } double MaltsevFallback() const { return OPT_VALUE("maltsev-fallback", m_MaltsevFallback, true); } + MALTSEV_MODE MaltsevMode() const { return OPT_VALUE("maltsev-mode", m_MaltsevMode.type, true); } double MassChangeFraction() const { return m_CmdLine.optionValues.m_MassChangeFraction; } diff --git a/src/typedefs.h b/src/typedefs.h index 635782b57..a3b1a45d3 100755 --- a/src/typedefs.h +++ b/src/typedefs.h @@ -816,6 +816,14 @@ const COMPASUnorderedMap REMNANT_MASS_PR { REMNANT_MASS_PRESCRIPTION::MALTSEV2024, "MALTSEV2024" } }; +// maltsev remnant mass prescription variant +enum class MALTSEV_MODE: int { OPTIMISTIC, BALANCED, PESSIMISTIC }; +const COMPASUnorderedMap MALTSEV_MODE_LABEL = { + { MALTSEV_MODE::OPTIMISTIC, "OPTIMISTIC" }, + { MALTSEV_MODE::BALANCED, "BALANCED" }, + { MALTSEV_MODE::PESSIMISTIC, "PESSIMISTIC"}, +}; + // response of star to spin-up beyond the Keplerian frequency enum class RESPONSE_TO_SPIN_UP: int { TRANSFER_TO_ORBIT, KEPLERIAN_LIMIT, NO_LIMIT }; const COMPASUnorderedMap RESPONSE_TO_SPIN_UP_LABEL = { From 1a4ffb80cc5ee4a5dfdb5ea2560b929b1ebc8ecf Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Thu, 12 Jun 2025 00:28:56 +0200 Subject: [PATCH 11/36] cleanup --- src/GiantBranch.cpp | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index 89cd0a9fc..7f921e668 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1304,8 +1304,10 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, ST_VECTOR mtHist = MassTransferDonorHistory(); // mass transfer history vector MT_CASE massTransferCase = MT_CASE::OTHER; double log10Z = m_Log10Metallicity - LOG10_ZSOL; // log_{10} (Z/Zsol), for convenience + double log10Zsol_div_10 = -1; + double log10Zsol_div_50 = -1.69897; double M1, M2, M3; - double remnantMass; + double remnantMass; if (utils::Compare(p_COCoreMass, MALTSEV2024_MMIN) < 0) { // NS formation regardless of metallicity and MT history m_SupernovaDetails.fallbackFraction = 0; @@ -1317,17 +1319,19 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, } else { // Determine MT history - this will tell us which Schneider MT case prescription should be used - // RTW add in the code here for the different cases double log10Z_bounded; - switch (OPTIONS->MaltsevMode()) { // TODO + switch (OPTIONS->MaltsevMode()) { - case MALTSEV_MODE::OPTIMISTIC: // TODO + case MALTSEV_MODE::OPTIMISTIC: log10Z_bounded = log10Z; - case MALTSEV_MODE::BALANCED: // TODO - log10Z_bounded = std::min(std::max(log10Z, LOG10_ZSOL/50), LOG10_ZSOL); - case MALTSEV_MODE::PESSIMISTIC: // TODO - log10Z_bounded = std::min(std::max(log10Z, LOG10_ZSOL/10), LOG10_ZSOL); - default: // unknown MT_CASE + break; + case MALTSEV_MODE::BALANCED: + log10Z_bounded = std::min(std::max(log10Z, log10Zsol_div_50), LOG10_ZSOL); + break; + case MALTSEV_MODE::PESSIMISTIC: + log10Z_bounded = std::min(std::max(log10Z, log10Zsol_div_10), LOG10_ZSOL); + break; + default: // TODO: rewrite this // the only way this can happen is if someone added an MT_CASE // and it isn't accounted for in this code. We should not default here, with or without a warning. From a2dd4307cfe0354e4b26e449a36eac20bd1e8523 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Sat, 14 Jun 2025 22:11:23 +0200 Subject: [PATCH 12/36] fixed bug in upper limit of Maltsev variations --- src/GiantBranch.cpp | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index 7f921e668..a60ab07a3 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1304,11 +1304,21 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, ST_VECTOR mtHist = MassTransferDonorHistory(); // mass transfer history vector MT_CASE massTransferCase = MT_CASE::OTHER; double log10Z = m_Log10Metallicity - LOG10_ZSOL; // log_{10} (Z/Zsol), for convenience - double log10Zsol_div_10 = -1; - double log10Zsol_div_50 = -1.69897; + double log10_1 = 0; // useful for the limits later + double log10_1_div_10 = -1; // useful for the limits later + double log10_1_div_50 = -1.69897; // useful for the limits later double M1, M2, M3; double remnantMass; + std::cout << + "\nLOG10_ZSOL = " << LOG10_ZSOL << + "\nlog10Zsol_div_10 = " << log10Zsol_div_10 << + "\nlog10Zsol_div_50 = " << log10Zsol_div_50 << + "\nm_Log10Metallicity = " << m_Log10Metallicity << + "\nlog10Z = " << log10Z << std::endl; + + + if (utils::Compare(p_COCoreMass, MALTSEV2024_MMIN) < 0) { // NS formation regardless of metallicity and MT history m_SupernovaDetails.fallbackFraction = 0; remnantMass = 1.35; //CalculateRemnantNSMassMullerMandel(p_COCoreMass, p_HeCoreMass); @@ -1319,17 +1329,17 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, } else { // Determine MT history - this will tell us which Schneider MT case prescription should be used - double log10Z_bounded; + double log10Z_bounded; // This is really log10(Z/Zsol), so it is 0 for Z=Zsol, -1 for Z=Zsol/10 and log10(1/50) for ... switch (OPTIONS->MaltsevMode()) { case MALTSEV_MODE::OPTIMISTIC: log10Z_bounded = log10Z; break; case MALTSEV_MODE::BALANCED: - log10Z_bounded = std::min(std::max(log10Z, log10Zsol_div_50), LOG10_ZSOL); + log10Z_bounded = std::min(std::max(log10Z, log10_1_div_50), log10_1); break; case MALTSEV_MODE::PESSIMISTIC: - log10Z_bounded = std::min(std::max(log10Z, log10Zsol_div_10), LOG10_ZSOL); + log10Z_bounded = std::min(std::max(log10Z, log10_1_div_10), log10_1); break; default: // TODO: rewrite this From 4528763a4e567825c9b5abd97782909b4dac3dfa Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Sat, 14 Jun 2025 22:29:04 +0200 Subject: [PATCH 13/36] removed print statements --- src/GiantBranch.cpp | 9 --------- 1 file changed, 9 deletions(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index a60ab07a3..4bdfb89b1 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1310,15 +1310,6 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, double M1, M2, M3; double remnantMass; - std::cout << - "\nLOG10_ZSOL = " << LOG10_ZSOL << - "\nlog10Zsol_div_10 = " << log10Zsol_div_10 << - "\nlog10Zsol_div_50 = " << log10Zsol_div_50 << - "\nm_Log10Metallicity = " << m_Log10Metallicity << - "\nlog10Z = " << log10Z << std::endl; - - - if (utils::Compare(p_COCoreMass, MALTSEV2024_MMIN) < 0) { // NS formation regardless of metallicity and MT history m_SupernovaDetails.fallbackFraction = 0; remnantMass = 1.35; //CalculateRemnantNSMassMullerMandel(p_COCoreMass, p_HeCoreMass); From 0dc8e1bdf953ab906c501ee3f3f2370f36db1fe7 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Sun, 15 Jun 2025 14:57:00 +0200 Subject: [PATCH 14/36] added Klencki linear AM loss prescription, variant of MacLeod linear --- src/BaseBinaryStar.cpp | 20 +++++++++++++++++--- src/LogTypedefs.h | 12 ++++++------ src/Options.cpp | 20 ++++++++++---------- src/Options.h | 8 ++++---- src/typedefs.h | 3 ++- 5 files changed, 39 insertions(+), 24 deletions(-) diff --git a/src/BaseBinaryStar.cpp b/src/BaseBinaryStar.cpp index f8d6b83b3..96b68ac75 100644 --- a/src/BaseBinaryStar.cpp +++ b/src/BaseBinaryStar.cpp @@ -1862,18 +1862,32 @@ double BaseBinaryStar::CalculateGammaAngularMomentumLoss_Static(const double p_D } break; case MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::MACLEOD_LINEAR : { // linear interpolation on separation between accretor and L2 point - // interpolate in separation between a_acc and a_L2, both normalized to units of separation a + // Interpolate linearly in separation between a_acc and a_L2, both normalized to units of separation a double q = p_AccretorMass / p_DonorMass; double qPlus1 = 1.0 + q; double aL2 = std::sqrt(M_SQRT2); // roughly, coincides with CIRCUMBINARY_RING def above double aAcc = 1.0 / qPlus1; double fMacleod = p_IsAccretorDegenerate - ? OPTIONS->MassTransferJlossMacLeodLinearFractionDegen() - : OPTIONS->MassTransferJlossMacLeodLinearFractionNonDegen(); + ? OPTIONS->MassTransferJlossLinearFractionDegen() + : OPTIONS->MassTransferJlossLinearFractionNonDegen(); double aGamma = aAcc + (aL2 - aAcc) * fMacleod; gamma = aGamma * aGamma * qPlus1 * qPlus1 / q; } break; + case MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::KLENCKI_LINEAR : { // linear interpolation on separation between accretor and L2 point + // Interpolate linearly in specific AM loss parameter gamma + double q = p_AccretorMass / p_DonorMass; + double qPlus1 = 1.0 + q; + double qPlus1SquaredByQ = qPlus1 * qPlus1 / q; + double aL2 = std::sqrt(M_SQRT2); // roughly, coincides with CIRCUMBINARY_RING def above + double aAcc = 1.0 / qPlus1; + double gammaL2 = aL2 * aL2 * qPlus1SquaredByQ; + double gammaAcc = aAcc * aAcc * qPlus1SquaredByQ; + double fKlencki = p_IsAccretorDegenerate + ? OPTIONS->MassTransferJlossLinearFractionDegen() + : OPTIONS->MassTransferJlossLinearFractionNonDegen(); + double gamma = gammaAcc + (gammaL2 - gammaAcc) * fKlencki; + } break; default: // unknown prescription // the only way this can happen is if someone added an MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION // and it isn't accounted for in this code. We should not default here, with or without a warning. diff --git a/src/LogTypedefs.h b/src/LogTypedefs.h index ebbfddfea..a4c7ee37a 100644 --- a/src/LogTypedefs.h +++ b/src/LogTypedefs.h @@ -928,8 +928,8 @@ enum class PROGRAM_OPTION: int { MT_FRACTION_ACCRETED, MT_JLOSS, - MT_JLOSS_MACLEOD_LINEAR_FRACTION_DEGEN, - MT_JLOSS_MACLEOD_LINEAR_FRACTION_NON_DEGEN, + MT_JLOSS_LINEAR_FRACTION_DEGEN, + MT_JLOSS_LINEAR_FRACTION_NON_DEGEN, MT_REJUVENATION_PRESCRIPTION, MT_THERMALLY_LIMITED_VARIATION, @@ -1155,8 +1155,8 @@ const COMPASUnorderedMap PROGRAM_OPTION_LABEL = { { PROGRAM_OPTION::MT_FRACTION_ACCRETED, "MT_FRACTION_ACCRETED" }, { PROGRAM_OPTION::MT_JLOSS, "MT_JLOSS" }, - { PROGRAM_OPTION::MT_JLOSS_MACLEOD_LINEAR_FRACTION_DEGEN, "MT_JLOSS_MACLEOD_LINEAR_FRACTION_DEGEN" }, - { PROGRAM_OPTION::MT_JLOSS_MACLEOD_LINEAR_FRACTION_NON_DEGEN, "MT_JLOSS_MACLEOD_LINEAR_FRACTION_NON_DEGEN" }, + { PROGRAM_OPTION::MT_JLOSS_LINEAR_FRACTION_DEGEN, "MT_JLOSS_LINEAR_FRACTION_DEGEN" }, + { PROGRAM_OPTION::MT_JLOSS_LINEAR_FRACTION_NON_DEGEN, "MT_JLOSS_LINEAR_FRACTION_NON_DEGEN" }, { PROGRAM_OPTION::MT_REJUVENATION_PRESCRIPTION, "MT_REJUVENATION_PRESCRIPTION" }, { PROGRAM_OPTION::MT_THERMALLY_LIMITED_VARIATION, "MT_THERMALLY_LIMITED_VARIATION" }, @@ -1740,8 +1740,8 @@ const std::map PROGRAM_OPTION_DETAIL = { { PROGRAM_OPTION::MT_FRACTION_ACCRETED, { TYPENAME::DOUBLE, "PO_MT_Fraction_Accreted", "-", 24, 15}}, { PROGRAM_OPTION::MT_JLOSS, { TYPENAME::DOUBLE, "PO_MT_JLoss", "-", 24, 15}}, - { PROGRAM_OPTION::MT_JLOSS_MACLEOD_LINEAR_FRACTION_DEGEN, { TYPENAME::DOUBLE, "PO_MT_JLoss_Macleod_Linear_Frac_Degen", "-", 24, 15}}, - { PROGRAM_OPTION::MT_JLOSS_MACLEOD_LINEAR_FRACTION_NON_DEGEN, { TYPENAME::DOUBLE, "PO_MT_JLoss_Macleod_Linear_Frac_Non_Degen", "-", 24, 15}}, + { PROGRAM_OPTION::MT_JLOSS_LINEAR_FRACTION_DEGEN, { TYPENAME::DOUBLE, "PO_MT_JLoss_Linear_Frac_Degen", "-", 24, 15}}, + { PROGRAM_OPTION::MT_JLOSS_LINEAR_FRACTION_NON_DEGEN, { TYPENAME::DOUBLE, "PO_MT_JLoss_Linear_Frac_Non_Degen", "-", 24, 15}}, { PROGRAM_OPTION::MT_REJUVENATION_PRESCRIPTION, { TYPENAME::INT, "PO_MT_Rejuvenation_Prscrptn", "-", 4, 1 }}, { PROGRAM_OPTION::MT_THERMALLY_LIMITED_VARIATION, { TYPENAME::INT, "PO_MT_Thermally_Lmtd_Variation", "-", 4, 1 }}, diff --git a/src/Options.cpp b/src/Options.cpp index d19bdde4d..c404000da 100644 --- a/src/Options.cpp +++ b/src/Options.cpp @@ -483,8 +483,8 @@ void Options::OptionValues::Initialise() { // Mass transfer angular momentum loss prescription options m_MassTransferJloss = 1.0; - m_MassTransferJlossMacLeodLinearFractionDegen = 0.5; - m_MassTransferJlossMacLeodLinearFractionNonDegen = 0.5; + m_MassTransferJlossLinearFractionDegen = 0.5; + m_MassTransferJlossLinearFractionNonDegen = 0.5; m_MassTransferAngularMomentumLossPrescription.type = MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::ISOTROPIC_RE_EMISSION; m_MassTransferAngularMomentumLossPrescription.typeString = MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION_LABEL.at(m_MassTransferAngularMomentumLossPrescription.type); @@ -1488,14 +1488,14 @@ bool Options::AddOptions(OptionValues *p_Options, po::options_description *p_Opt ("Fraction of specific angular momentum which non-accreted matter removes from the system (default = " + std::to_string(p_Options->m_MassTransferJloss) + ")").c_str() ) ( - "mass-transfer-jloss-macleod-linear-fraction-degen", - po::value(&p_Options->m_MassTransferJlossMacLeodLinearFractionDegen)->default_value(p_Options->m_MassTransferJlossMacLeodLinearFractionDegen), - ("Interpolation fraction for jloss prescription for degenerate accretors, requires --mass-transfer-angular-momentum-loss-prescription=MACLEOD_LINEAR. 0 is gamma_acc, 1 is gamma_L2 (default = " + std::to_string(p_Options->m_MassTransferJlossMacLeodLinearFractionDegen) + ")").c_str() + "mass-transfer-jloss-linear-fraction-degen", + po::value(&p_Options->m_MassTransferJlossLinearFractionDegen)->default_value(p_Options->m_MassTransferJlossLinearFractionDegen), + ("Interpolation fraction for jloss prescription for degenerate accretors, requires --mass-transfer-angular-momentum-loss-prescription=MACLEOD_LINEAR or KLENCKI_LINEAR. 0 is gamma_acc, 1 is gamma_L2 (default = " + std::to_string(p_Options->m_MassTransferJlossLinearFractionDegen) + ")").c_str() ) ( - "mass-transfer-jloss-macleod-linear-fraction-non-degen", - po::value(&p_Options->m_MassTransferJlossMacLeodLinearFractionNonDegen)->default_value(p_Options->m_MassTransferJlossMacLeodLinearFractionNonDegen), - ("Interpolation fraction for jloss prescription for non-degenerate accretors, requires --mass-transfer-angular-momentum-loss-prescription=MACLEOD_LINEAR. 0 is gamma_acc, 1 is gamma_L2 (default = " + std::to_string(p_Options->m_MassTransferJlossMacLeodLinearFractionNonDegen) + ")").c_str() + "mass-transfer-jloss-linear-fraction-non-degen", + po::value(&p_Options->m_MassTransferJlossLinearFractionNonDegen)->default_value(p_Options->m_MassTransferJlossLinearFractionNonDegen), + ("Interpolation fraction for jloss prescription for non-degenerate accretors, requires --mass-transfer-angular-momentum-loss-prescription=MACLEOD_LINEAR or KLENCKI_LINEAR. 0 is gamma_acc, 1 is gamma_L2 (default = " + std::to_string(p_Options->m_MassTransferJlossLinearFractionNonDegen) + ")").c_str() ) ( "mass-transfer-thermal-limit-C", @@ -5027,8 +5027,8 @@ COMPAS_VARIABLE Options::OptionValue(const T_ANY_PROPERTY p_Property) const { case PROGRAM_OPTION::MT_FRACTION_ACCRETED : value = MassTransferFractionAccreted(); break; case PROGRAM_OPTION::MT_JLOSS : value = MassTransferJloss(); break; - case PROGRAM_OPTION::MT_JLOSS_MACLEOD_LINEAR_FRACTION_DEGEN : value = MassTransferJlossMacLeodLinearFractionDegen(); break; - case PROGRAM_OPTION::MT_JLOSS_MACLEOD_LINEAR_FRACTION_NON_DEGEN : value = MassTransferJlossMacLeodLinearFractionNonDegen(); break; + case PROGRAM_OPTION::MT_JLOSS_LINEAR_FRACTION_DEGEN : value = MassTransferJlossLinearFractionDegen(); break; + case PROGRAM_OPTION::MT_JLOSS_LINEAR_FRACTION_NON_DEGEN : value = MassTransferJlossLinearFractionNonDegen(); break; case PROGRAM_OPTION::MT_REJUVENATION_PRESCRIPTION : value = static_cast(MassTransferRejuvenationPrescription()); break; case PROGRAM_OPTION::MT_THERMALLY_LIMITED_VARIATION : value = static_cast(MassTransferThermallyLimitedVariation()); break; diff --git a/src/Options.h b/src/Options.h index a68e6d041..84afa36fe 100755 --- a/src/Options.h +++ b/src/Options.h @@ -1040,8 +1040,8 @@ class Options { ENUM_OPT m_MassTransferThermallyLimitedVariation; // Choose how to deal with mass transfer if it is set as thermally limited. double m_MassTransferJloss; // Specific angular momentum of the material leaving the system (not accreted) - double m_MassTransferJlossMacLeodLinearFractionDegen; // Linear interpolation fraction for jloss for degenerate accretors, between accretor and L2 position - double m_MassTransferJlossMacLeodLinearFractionNonDegen; // Linear interpolation fraction for jloss for non-degenerate accretors, between accretor and L2 position + double m_MassTransferJlossLinearFractionDegen; // Linear interpolation fraction for jloss for degenerate accretors, between accretor and L2 position (either Macleod or Klencki linear) + double m_MassTransferJlossLinearFractionNonDegen; // Linear interpolation fraction for jloss for non-degenerate accretors, between accretor and L2 position (either Macleod or Klencki linear) ENUM_OPT m_MassTransferAngularMomentumLossPrescription; // Which mass transfer angular momentum loss prescription // Mass transfer rejuvenation prescription @@ -1596,8 +1596,8 @@ class Options { double MassTransferFractionAccreted() const { return OPT_VALUE("mass-transfer-fa", m_MassTransferFractionAccreted, true); } double MassTransferJloss() const { return OPT_VALUE("mass-transfer-jloss", m_MassTransferJloss, true); } - double MassTransferJlossMacLeodLinearFractionDegen() const { return OPT_VALUE("mass-transfer-jloss-macleod-linear-fraction-degen", m_MassTransferJlossMacLeodLinearFractionDegen, true); } - double MassTransferJlossMacLeodLinearFractionNonDegen() const { return OPT_VALUE("mass-transfer-jloss-macleod-linear-fraction-non-degen", m_MassTransferJlossMacLeodLinearFractionNonDegen, true); } + double MassTransferJlossLinearFractionDegen() const { return OPT_VALUE("mass-transfer-jloss-linear-fraction-degen", m_MassTransferJlossLinearFractionDegen, true); } + double MassTransferJlossLinearFractionNonDegen() const { return OPT_VALUE("mass-transfer-jloss-linear-fraction-non-degen", m_MassTransferJlossLinearFractionNonDegen, true); } MT_REJUVENATION_PRESCRIPTION MassTransferRejuvenationPrescription() const { return OPT_VALUE("mass-transfer-rejuvenation-prescription", m_MassTransferRejuvenationPrescription.type, true); } MT_THERMALLY_LIMITED_VARIATION MassTransferThermallyLimitedVariation() const { return OPT_VALUE("mass-transfer-thermal-limit-accretor-multiplier", m_MassTransferThermallyLimitedVariation.type, true); } double MaxEvolutionTime() const { return OPT_VALUE("maximum-evolution-time", m_MaxEvolutionTime, true); } diff --git a/src/typedefs.h b/src/typedefs.h index a3b1a45d3..543057c8b 100755 --- a/src/typedefs.h +++ b/src/typedefs.h @@ -650,12 +650,13 @@ const COMPASUnorderedMap MT_A }; // mass transfer angular momentum loss prescriptions -enum class MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION: int { JEANS, ISOTROPIC_RE_EMISSION, CIRCUMBINARY_RING, MACLEOD_LINEAR, ARBITRARY }; +enum class MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION: int { JEANS, ISOTROPIC_RE_EMISSION, CIRCUMBINARY_RING, MACLEOD_LINEAR, KLENCKI_LINEAR, ARBITRARY }; const COMPASUnorderedMap MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION_LABEL = { { MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::JEANS, "JEANS" }, { MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::ISOTROPIC_RE_EMISSION, "ISOTROPIC" }, { MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::CIRCUMBINARY_RING, "CIRCUMBINARY" }, { MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::MACLEOD_LINEAR, "MACLEOD_LINEAR" }, + { MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::KLENCKI_LINEAR, "KLENCKI_LINEAR" }, { MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::ARBITRARY, "ARBITRARY" } }; From 88829deb255da3fb46f8f7ebb9ad898b8d178f83 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Tue, 24 Jun 2025 18:37:38 +0200 Subject: [PATCH 15/36] fixed bug with klencki gamma --- src/BaseBinaryStar.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/BaseBinaryStar.cpp b/src/BaseBinaryStar.cpp index 96b68ac75..ed6936bb8 100644 --- a/src/BaseBinaryStar.cpp +++ b/src/BaseBinaryStar.cpp @@ -1886,7 +1886,7 @@ double BaseBinaryStar::CalculateGammaAngularMomentumLoss_Static(const double p_D double fKlencki = p_IsAccretorDegenerate ? OPTIONS->MassTransferJlossLinearFractionDegen() : OPTIONS->MassTransferJlossLinearFractionNonDegen(); - double gamma = gammaAcc + (gammaL2 - gammaAcc) * fKlencki; + gamma = gammaAcc + (gammaL2 - gammaAcc) * fKlencki; } break; default: // unknown prescription // the only way this can happen is if someone added an MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION From 2d941b69e84a1e86dd75001ff72ce2371a82449b Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Tue, 22 Jul 2025 23:27:16 +0100 Subject: [PATCH 16/36] minor fix for one of the Maltsev values --- src/constants.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/constants.h b/src/constants.h index 5c18a4a25..7c8bda2ab 100755 --- a/src/constants.h +++ b/src/constants.h @@ -412,7 +412,7 @@ constexpr double MALTSEV2024_M2S = 7.2; constexpr double MALTSEV2024_M2C = 7.1; constexpr double MALTSEV2024_M2B = 8.3; constexpr double MALTSEV2024_M2A = 8.4; -constexpr double MALTSEV2024_M3S = 12.9; +constexpr double MALTSEV2024_M3S = 13.0; constexpr double MALTSEV2024_M3C = 13.2; constexpr double MALTSEV2024_M3B = 15.2; constexpr double MALTSEV2024_M3A = 15.4; From 412a8fde7d5564b177286056f1193e0a667583ad Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Mon, 18 Aug 2025 11:10:29 +0200 Subject: [PATCH 17/36] removed code that wasn't specifically relevant to just the Maltsev modifications. These changes will be added to another PR --- src/BaseBinaryStar.cpp | 20 +++----------------- src/Errors.cpp | 3 ++- src/LogTypedefs.h | 12 ++++++------ src/Options.cpp | 20 ++++++++++---------- src/Options.h | 10 +++++----- src/typedefs.h | 3 +-- 6 files changed, 27 insertions(+), 41 deletions(-) diff --git a/src/BaseBinaryStar.cpp b/src/BaseBinaryStar.cpp index c7d33ffb5..fa502f712 100644 --- a/src/BaseBinaryStar.cpp +++ b/src/BaseBinaryStar.cpp @@ -1861,32 +1861,18 @@ double BaseBinaryStar::CalculateGammaAngularMomentumLoss_Static(const double p_D } break; case MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::MACLEOD_LINEAR : { // linear interpolation on separation between accretor and L2 point - // Interpolate linearly in separation between a_acc and a_L2, both normalized to units of separation a + // interpolate in separation between a_acc and a_L2, both normalized to units of separation a double q = p_AccretorMass / p_DonorMass; double qPlus1 = 1.0 + q; double aL2 = std::sqrt(M_SQRT2); // roughly, coincides with CIRCUMBINARY_RING def above double aAcc = 1.0 / qPlus1; double fMacleod = p_IsAccretorDegenerate - ? OPTIONS->MassTransferJlossLinearFractionDegen() - : OPTIONS->MassTransferJlossLinearFractionNonDegen(); + ? OPTIONS->MassTransferJlossMacLeodLinearFractionDegen() + : OPTIONS->MassTransferJlossMacLeodLinearFractionNonDegen(); double aGamma = aAcc + (aL2 - aAcc) * fMacleod; gamma = aGamma * aGamma * qPlus1 * qPlus1 / q; } break; - case MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::KLENCKI_LINEAR : { // linear interpolation on separation between accretor and L2 point - // Interpolate linearly in specific AM loss parameter gamma - double q = p_AccretorMass / p_DonorMass; - double qPlus1 = 1.0 + q; - double qPlus1SquaredByQ = qPlus1 * qPlus1 / q; - double aL2 = std::sqrt(M_SQRT2); // roughly, coincides with CIRCUMBINARY_RING def above - double aAcc = 1.0 / qPlus1; - double gammaL2 = aL2 * aL2 * qPlus1SquaredByQ; - double gammaAcc = aAcc * aAcc * qPlus1SquaredByQ; - double fKlencki = p_IsAccretorDegenerate - ? OPTIONS->MassTransferJlossLinearFractionDegen() - : OPTIONS->MassTransferJlossLinearFractionNonDegen(); - gamma = gammaAcc + (gammaL2 - gammaAcc) * fKlencki; - } break; default: // unknown prescription // the only way this can happen is if someone added an MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION // and it isn't accounted for in this code. We should not default here, with or without a warning. diff --git a/src/Errors.cpp b/src/Errors.cpp index 397e5e079..f9dd3cdd5 100755 --- a/src/Errors.cpp +++ b/src/Errors.cpp @@ -1,4 +1,5 @@ -/* * Class Errors +/* + * Class Errors * * Provides global error handling functionality. * diff --git a/src/LogTypedefs.h b/src/LogTypedefs.h index 0597f6f0a..0a6a3c5f0 100644 --- a/src/LogTypedefs.h +++ b/src/LogTypedefs.h @@ -936,8 +936,8 @@ enum class PROGRAM_OPTION: int { MT_FRACTION_ACCRETED, MT_JLOSS, - MT_JLOSS_LINEAR_FRACTION_DEGEN, - MT_JLOSS_LINEAR_FRACTION_NON_DEGEN, + MT_JLOSS_MACLEOD_LINEAR_FRACTION_DEGEN, + MT_JLOSS_MACLEOD_LINEAR_FRACTION_NON_DEGEN, MT_REJUVENATION_PRESCRIPTION, MT_THERMALLY_LIMITED_VARIATION, @@ -1166,8 +1166,8 @@ const COMPASUnorderedMap PROGRAM_OPTION_LABEL = { { PROGRAM_OPTION::MT_FRACTION_ACCRETED, "MT_FRACTION_ACCRETED" }, { PROGRAM_OPTION::MT_JLOSS, "MT_JLOSS" }, - { PROGRAM_OPTION::MT_JLOSS_LINEAR_FRACTION_DEGEN, "MT_JLOSS_LINEAR_FRACTION_DEGEN" }, - { PROGRAM_OPTION::MT_JLOSS_LINEAR_FRACTION_NON_DEGEN, "MT_JLOSS_LINEAR_FRACTION_NON_DEGEN" }, + { PROGRAM_OPTION::MT_JLOSS_MACLEOD_LINEAR_FRACTION_DEGEN, "MT_JLOSS_MACLEOD_LINEAR_FRACTION_DEGEN" }, + { PROGRAM_OPTION::MT_JLOSS_MACLEOD_LINEAR_FRACTION_NON_DEGEN, "MT_JLOSS_MACLEOD_LINEAR_FRACTION_NON_DEGEN" }, { PROGRAM_OPTION::MT_REJUVENATION_PRESCRIPTION, "MT_REJUVENATION_PRESCRIPTION" }, { PROGRAM_OPTION::MT_THERMALLY_LIMITED_VARIATION, "MT_THERMALLY_LIMITED_VARIATION" }, @@ -1757,8 +1757,8 @@ const std::map PROGRAM_OPTION_DETAIL = { { PROGRAM_OPTION::MT_FRACTION_ACCRETED, { TYPENAME::DOUBLE, "PO_MT_Fraction_Accreted", "-", 24, 15}}, { PROGRAM_OPTION::MT_JLOSS, { TYPENAME::DOUBLE, "PO_MT_JLoss", "-", 24, 15}}, - { PROGRAM_OPTION::MT_JLOSS_LINEAR_FRACTION_DEGEN, { TYPENAME::DOUBLE, "PO_MT_JLoss_Linear_Frac_Degen", "-", 24, 15}}, - { PROGRAM_OPTION::MT_JLOSS_LINEAR_FRACTION_NON_DEGEN, { TYPENAME::DOUBLE, "PO_MT_JLoss_Linear_Frac_Non_Degen", "-", 24, 15}}, + { PROGRAM_OPTION::MT_JLOSS_MACLEOD_LINEAR_FRACTION_DEGEN, { TYPENAME::DOUBLE, "PO_MT_JLoss_Macleod_Linear_Frac_Degen", "-", 24, 15}}, + { PROGRAM_OPTION::MT_JLOSS_MACLEOD_LINEAR_FRACTION_NON_DEGEN, { TYPENAME::DOUBLE, "PO_MT_JLoss_Macleod_Linear_Frac_Non_Degen", "-", 24, 15}}, { PROGRAM_OPTION::MT_REJUVENATION_PRESCRIPTION, { TYPENAME::INT, "PO_MT_Rejuvenation_Prscrptn", "-", 4, 1 }}, { PROGRAM_OPTION::MT_THERMALLY_LIMITED_VARIATION, { TYPENAME::INT, "PO_MT_Thermally_Lmtd_Variation", "-", 4, 1 }}, diff --git a/src/Options.cpp b/src/Options.cpp index e00917889..ef774c396 100644 --- a/src/Options.cpp +++ b/src/Options.cpp @@ -483,8 +483,8 @@ void Options::OptionValues::Initialise() { // Mass transfer angular momentum loss prescription options m_MassTransferJloss = 1.0; - m_MassTransferJlossLinearFractionDegen = 0.5; - m_MassTransferJlossLinearFractionNonDegen = 0.5; + m_MassTransferJlossMacLeodLinearFractionDegen = 0.5; + m_MassTransferJlossMacLeodLinearFractionNonDegen = 0.5; m_MassTransferAngularMomentumLossPrescription.type = MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::ISOTROPIC_RE_EMISSION; m_MassTransferAngularMomentumLossPrescription.typeString = MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION_LABEL.at(m_MassTransferAngularMomentumLossPrescription.type); @@ -1491,14 +1491,14 @@ bool Options::AddOptions(OptionValues *p_Options, po::options_description *p_Opt ("Fraction of specific angular momentum which non-accreted matter removes from the system (default = " + std::to_string(p_Options->m_MassTransferJloss) + ")").c_str() ) ( - "mass-transfer-jloss-linear-fraction-degen", - po::value(&p_Options->m_MassTransferJlossLinearFractionDegen)->default_value(p_Options->m_MassTransferJlossLinearFractionDegen), - ("Interpolation fraction for jloss prescription for degenerate accretors, requires --mass-transfer-angular-momentum-loss-prescription=MACLEOD_LINEAR or KLENCKI_LINEAR. 0 is gamma_acc, 1 is gamma_L2 (default = " + std::to_string(p_Options->m_MassTransferJlossLinearFractionDegen) + ")").c_str() + "mass-transfer-jloss-macleod-linear-fraction-degen", + po::value(&p_Options->m_MassTransferJlossMacLeodLinearFractionDegen)->default_value(p_Options->m_MassTransferJlossMacLeodLinearFractionDegen), + ("Interpolation fraction for jloss prescription for degenerate accretors, requires --mass-transfer-angular-momentum-loss-prescription=MACLEOD_LINEAR. 0 is gamma_acc, 1 is gamma_L2 (default = " + std::to_string(p_Options->m_MassTransferJlossMacLeodLinearFractionDegen) + ")").c_str() ) ( - "mass-transfer-jloss-linear-fraction-non-degen", - po::value(&p_Options->m_MassTransferJlossLinearFractionNonDegen)->default_value(p_Options->m_MassTransferJlossLinearFractionNonDegen), - ("Interpolation fraction for jloss prescription for non-degenerate accretors, requires --mass-transfer-angular-momentum-loss-prescription=MACLEOD_LINEAR or KLENCKI_LINEAR. 0 is gamma_acc, 1 is gamma_L2 (default = " + std::to_string(p_Options->m_MassTransferJlossLinearFractionNonDegen) + ")").c_str() + "mass-transfer-jloss-macleod-linear-fraction-non-degen", + po::value(&p_Options->m_MassTransferJlossMacLeodLinearFractionNonDegen)->default_value(p_Options->m_MassTransferJlossMacLeodLinearFractionNonDegen), + ("Interpolation fraction for jloss prescription for non-degenerate accretors, requires --mass-transfer-angular-momentum-loss-prescription=MACLEOD_LINEAR. 0 is gamma_acc, 1 is gamma_L2 (default = " + std::to_string(p_Options->m_MassTransferJlossMacLeodLinearFractionNonDegen) + ")").c_str() ) ( "mass-transfer-thermal-limit-C", @@ -5045,8 +5045,8 @@ COMPAS_VARIABLE Options::OptionValue(const T_ANY_PROPERTY p_Property) const { case PROGRAM_OPTION::MT_FRACTION_ACCRETED : value = MassTransferFractionAccreted(); break; case PROGRAM_OPTION::MT_JLOSS : value = MassTransferJloss(); break; - case PROGRAM_OPTION::MT_JLOSS_LINEAR_FRACTION_DEGEN : value = MassTransferJlossLinearFractionDegen(); break; - case PROGRAM_OPTION::MT_JLOSS_LINEAR_FRACTION_NON_DEGEN : value = MassTransferJlossLinearFractionNonDegen(); break; + case PROGRAM_OPTION::MT_JLOSS_MACLEOD_LINEAR_FRACTION_DEGEN : value = MassTransferJlossMacLeodLinearFractionDegen(); break; + case PROGRAM_OPTION::MT_JLOSS_MACLEOD_LINEAR_FRACTION_NON_DEGEN : value = MassTransferJlossMacLeodLinearFractionNonDegen(); break; case PROGRAM_OPTION::MT_REJUVENATION_PRESCRIPTION : value = static_cast(MassTransferRejuvenationPrescription()); break; case PROGRAM_OPTION::MT_THERMALLY_LIMITED_VARIATION : value = static_cast(MassTransferThermallyLimitedVariation()); break; diff --git a/src/Options.h b/src/Options.h index ba33f98cd..ea6c65a33 100755 --- a/src/Options.h +++ b/src/Options.h @@ -1062,8 +1062,8 @@ class Options { ENUM_OPT m_MassTransferThermallyLimitedVariation; // Choose how to deal with mass transfer if it is set as thermally limited. double m_MassTransferJloss; // Specific angular momentum of the material leaving the system (not accreted) - double m_MassTransferJlossLinearFractionDegen; // Linear interpolation fraction for jloss for degenerate accretors, between accretor and L2 position (either Macleod or Klencki linear) - double m_MassTransferJlossLinearFractionNonDegen; // Linear interpolation fraction for jloss for non-degenerate accretors, between accretor and L2 position (either Macleod or Klencki linear) + double m_MassTransferJlossMacLeodLinearFractionDegen; // Linear interpolation fraction for jloss for degenerate accretors, between accretor and L2 position + double m_MassTransferJlossMacLeodLinearFractionNonDegen; // Linear interpolation fraction for jloss for non-degenerate accretors, between accretor and L2 position ENUM_OPT m_MassTransferAngularMomentumLossPrescription; // Which mass transfer angular momentum loss prescription // Mass transfer rejuvenation prescription @@ -1593,7 +1593,7 @@ class Options { double MassChangeFraction() const { return m_CmdLine.optionValues.m_MassChangeFraction; } MASS_LOSS_PRESCRIPTION MassLossPrescription() const { return OPT_VALUE("mass-loss-prescription", m_MassLossPrescription.type, true); } - + double MassRatio() const { return OPT_VALUE("mass-ratio", m_MassRatio, true); } MASS_RATIO_DISTRIBUTION MassRatioDistribution() const { return OPT_VALUE("mass-ratio-distribution", m_MassRatioDistribution.type, true); } double MassRatioDistributionMax() const { return OPT_VALUE("mass-ratio-max", m_MassRatioDistributionMax, true); } @@ -1622,8 +1622,8 @@ class Options { double MassTransferFractionAccreted() const { return OPT_VALUE("mass-transfer-fa", m_MassTransferFractionAccreted, true); } double MassTransferJloss() const { return OPT_VALUE("mass-transfer-jloss", m_MassTransferJloss, true); } - double MassTransferJlossLinearFractionDegen() const { return OPT_VALUE("mass-transfer-jloss-linear-fraction-degen", m_MassTransferJlossLinearFractionDegen, true); } - double MassTransferJlossLinearFractionNonDegen() const { return OPT_VALUE("mass-transfer-jloss-linear-fraction-non-degen", m_MassTransferJlossLinearFractionNonDegen, true); } + double MassTransferJlossMacLeodLinearFractionDegen() const { return OPT_VALUE("mass-transfer-jloss-macleod-linear-fraction-degen", m_MassTransferJlossMacLeodLinearFractionDegen, true); } + double MassTransferJlossMacLeodLinearFractionNonDegen() const { return OPT_VALUE("mass-transfer-jloss-macleod-linear-fraction-non-degen", m_MassTransferJlossMacLeodLinearFractionNonDegen, true); } MT_REJUVENATION_PRESCRIPTION MassTransferRejuvenationPrescription() const { return OPT_VALUE("mass-transfer-rejuvenation-prescription", m_MassTransferRejuvenationPrescription.type, true); } MT_THERMALLY_LIMITED_VARIATION MassTransferThermallyLimitedVariation() const { return OPT_VALUE("mass-transfer-thermal-limit-accretor-multiplier", m_MassTransferThermallyLimitedVariation.type, true); } double MaxEvolutionTime() const { return OPT_VALUE("maximum-evolution-time", m_MaxEvolutionTime, true); } diff --git a/src/typedefs.h b/src/typedefs.h index 62e8aed3e..17cf6be3a 100755 --- a/src/typedefs.h +++ b/src/typedefs.h @@ -650,13 +650,12 @@ const COMPASUnorderedMap MT_A }; // mass transfer angular momentum loss prescriptions -enum class MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION: int { JEANS, ISOTROPIC_RE_EMISSION, CIRCUMBINARY_RING, MACLEOD_LINEAR, KLENCKI_LINEAR, ARBITRARY }; +enum class MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION: int { JEANS, ISOTROPIC_RE_EMISSION, CIRCUMBINARY_RING, MACLEOD_LINEAR, ARBITRARY }; const COMPASUnorderedMap MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION_LABEL = { { MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::JEANS, "JEANS" }, { MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::ISOTROPIC_RE_EMISSION, "ISOTROPIC" }, { MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::CIRCUMBINARY_RING, "CIRCUMBINARY" }, { MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::MACLEOD_LINEAR, "MACLEOD_LINEAR" }, - { MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::KLENCKI_LINEAR, "KLENCKI_LINEAR" }, { MT_ANGULAR_MOMENTUM_LOSS_PRESCRIPTION::ARBITRARY, "ARBITRARY" } }; From 62c58fef34dd0d14ce652eaed4ec2684a2edb334 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Mon, 18 Aug 2025 11:27:33 +0200 Subject: [PATCH 18/36] comment cleanup --- src/GiantBranch.cpp | 12 ++---------- src/LogTypedefs.h | 8 ++++---- 2 files changed, 6 insertions(+), 14 deletions(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index 68fbb2d3a..706e996d6 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1329,15 +1329,8 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, log10Z_bounded = std::min(std::max(log10Z, log10_1_div_10), log10_1); break; default: - // TODO: rewrite this - // the only way this can happen is if someone added an MT_CASE - // and it isn't accounted for in this code. We should not default here, with or without a warning. - // We are here because DetermineMassTransferTypeAsDonor() returned an MT_CASE this code doesn't - // account for, and that should be flagged as an error and result in termination of the evolution - // of the star or binary. - // The correct fix for this is to add code for the missing MT_CASE or, if the missing MT_CASE is - // incorrect/superfluous, remove it from the possible MT_CASE values. - + // Unrecognized MALTSEV_MODE. Only possible if a new one is added but an + // extra flag is not created here. THROW_ERROR(ERROR::UNKNOWN_MALTSEV_MODE); // throw error } @@ -1973,7 +1966,6 @@ STELLAR_TYPE GiantBranch::ResolveCoreCollapseSN() { case REMNANT_MASS_PRESCRIPTION::MALTSEV2024: // Maltsev+ 2024 //fallbackfraction determined interally - //m_SupernovaDetails.fallbackFraction = 0.0; // no subsequent kick adjustment by fallback fraction needed; MULLERMANDEL kick prescription should be used m_Mass = CalculateRemnantMassByMaltsev2024(m_COCoreMass, m_HeCoreMass); break; diff --git a/src/LogTypedefs.h b/src/LogTypedefs.h index 0a6a3c5f0..0a088e72b 100644 --- a/src/LogTypedefs.h +++ b/src/LogTypedefs.h @@ -1506,8 +1506,8 @@ const std::map BINARY_PROPERTY_DETAIL = { { BINARY_PROPERTY::RLOF_POST_MT_STAR2_MASS, { TYPENAME::DOUBLE, "Mass(2)>MT", "Msol", 24, 15}}, { BINARY_PROPERTY::RLOF_POST_MT_STAR1_RADIUS, { TYPENAME::DOUBLE, "Radius(1)>MT", "Rsol", 24, 15}}, { BINARY_PROPERTY::RLOF_POST_MT_STAR2_RADIUS, { TYPENAME::DOUBLE, "Radius(2)>MT", "Rsol", 24, 15}}, - { BINARY_PROPERTY::RLOF_POST_MT_STAR1_TEFF, { TYPENAME::DOUBLE, "Teff(1)>MT", "K?", 24, 15}}, - { BINARY_PROPERTY::RLOF_POST_MT_STAR2_TEFF, { TYPENAME::DOUBLE, "Teff(2)>MT", "K?", 24, 15}}, + { BINARY_PROPERTY::RLOF_POST_MT_STAR1_TEFF, { TYPENAME::DOUBLE, "Teff(1)>MT", "K", 24, 15}}, + { BINARY_PROPERTY::RLOF_POST_MT_STAR2_TEFF, { TYPENAME::DOUBLE, "Teff(2)>MT", "K", 24, 15}}, { BINARY_PROPERTY::RLOF_POST_MT_STAR1_LUM, { TYPENAME::DOUBLE, "Lum(1)>MT", "Lsol", 24, 15}}, { BINARY_PROPERTY::RLOF_POST_MT_STAR2_LUM, { TYPENAME::DOUBLE, "Lum(2)>MT", "Lsol", 24, 15}}, { BINARY_PROPERTY::RLOF_POST_MT_STAR1_RLOF, { TYPENAME::BOOL, "RLOF(1)>MT", "State", 0, 0 }}, @@ -1524,8 +1524,8 @@ const std::map BINARY_PROPERTY_DETAIL = { { BINARY_PROPERTY::RLOF_PRE_MT_STAR2_MASS, { TYPENAME::DOUBLE, "Mass(2) Date: Mon, 18 Aug 2025 11:29:31 +0200 Subject: [PATCH 19/36] typo fix --- src/GiantBranch.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index 706e996d6..b963cabf3 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1965,7 +1965,7 @@ STELLAR_TYPE GiantBranch::ResolveCoreCollapseSN() { case REMNANT_MASS_PRESCRIPTION::MALTSEV2024: // Maltsev+ 2024 - //fallbackfraction determined interally + //fallbackfraction determined internally m_Mass = CalculateRemnantMassByMaltsev2024(m_COCoreMass, m_HeCoreMass); break; From 3e77a91c825fb2e2ecb66c3614c8d29f4c1e8513 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Mon, 18 Aug 2025 11:31:14 +0200 Subject: [PATCH 20/36] changelog --- src/changelog.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/changelog.h b/src/changelog.h index 3c48f6fb9..19a87a718 100644 --- a/src/changelog.h +++ b/src/changelog.h @@ -1650,6 +1650,9 @@ // 03.23.01 IM - August 18, 2025 - Enhancement, defect repair: // - In the MALTSEV SN prescription, treat wind-stripped stars as if they experienced case B mass transfer // - Limit the output of CalculateEtaPTY() [Helium accretion efficiency onto WDs from Piersanti+ 2014, A3] to be in [0,1] +// 03.23.02 RTW - August 18, 2025 - Enhancement: +// - Updated Maltsev SN prescription, to include Maltsev mode (extrapolation variant outside of Z bounds), +// fallback option, fixed remnant mass, and added lum and teff as attributes of RLOFProperties // // // Version string format is MM.mm.rr, where From 99a959ddac80e7e0ed1f9596343194084e9bed92 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Mon, 18 Aug 2025 11:48:40 +0200 Subject: [PATCH 21/36] documentation --- ...d-logfiles-record-specification-binary.rst | 129 ++++++++++++++++++ 1 file changed, 129 insertions(+) diff --git a/online-docs/pages/User guide/COMPAS output/standard-logfiles-record-specification-binary.rst b/online-docs/pages/User guide/COMPAS output/standard-logfiles-record-specification-binary.rst index 47ca673d4..79c7b1095 100644 --- a/online-docs/pages/User guide/COMPAS output/standard-logfiles-record-specification-binary.rst +++ b/online-docs/pages/User guide/COMPAS output/standard-logfiles-record-specification-binary.rst @@ -790,6 +790,38 @@ Binary Properties * - Header String: - SemiMajorAxis>MT +.. flat-table:: + :widths: 25 75 1 1 + :header-rows: 0 + :class: aligned-text + + * - :cspan:`2` **RLOF_POST_MT_STAR1_LUM** + - + * - Data type: + - DOUBLE + * - COMPAS variable: + - BaseBinaryStar::m_RLOFDetails.propsPostMT→lum1 + * - Description: + - Luminosity (\ :math:`L_\odot`) of the primary immediately after RLOF. + * - Header String: + - Lum(1)>MT + +.. flat-table:: + :widths: 25 75 1 1 + :header-rows: 0 + :class: aligned-text + + * - :cspan:`2` **RLOF_POST_MT_STAR2_LUM** + - + * - Data type: + - DOUBLE + * - COMPAS variable: + - BaseBinaryStar::m_RLOFDetails.propsPostMT→lum2 + * - Description: + - Luminosity (\ :math:`L_\odot`) of the secondary immediately after RLOF. + * - Header String: + - Lum(2)>MT + .. flat-table:: :widths: 25 75 1 1 :header-rows: 0 @@ -854,6 +886,38 @@ Binary Properties * - Header String: - Radius(2)>MT +.. flat-table:: + :widths: 25 75 1 1 + :header-rows: 0 + :class: aligned-text + + * - :cspan:`2` **RLOF_POST_MT_STAR1_TEFF** + - + * - Data type: + - DOUBLE + * - COMPAS variable: + - BaseBinaryStar::m_RLOFDetails.propsPostMT→teff1 + * - Description: + - Effective temperature (\ :math:`K`) of the primary immediately after RLOF. + * - Header String: + - Teff(1)>MT + +.. flat-table:: + :widths: 25 75 1 1 + :header-rows: 0 + :class: aligned-text + + * - :cspan:`2` **RLOF_POST_MT_STAR2_TEFF** + - + * - Data type: + - DOUBLE + * - COMPAS variable: + - BaseBinaryStar::m_RLOFDetails.propsPostMT→teff2 + * - Description: + - Effective temperature (\ :math:`K`) of the secondary immediately after RLOF. + * - Header String: + - Teff(2)>MT + .. flat-table:: :widths: 25 75 1 1 :header-rows: 0 @@ -1026,6 +1090,39 @@ but not both. If both are printed then the file will contain two columns with th * - Header String: - SemiMajorAxis Date: Mon, 18 Aug 2025 11:53:31 +0200 Subject: [PATCH 22/36] typo --- src/GiantBranch.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index b963cabf3..e820514ec 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1965,7 +1965,7 @@ STELLAR_TYPE GiantBranch::ResolveCoreCollapseSN() { case REMNANT_MASS_PRESCRIPTION::MALTSEV2024: // Maltsev+ 2024 - //fallbackfraction determined internally + //fallback fraction determined internally m_Mass = CalculateRemnantMassByMaltsev2024(m_COCoreMass, m_HeCoreMass); break; From 479de92f43a4e475b23b3e499e618b34508c22b5 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Mon, 18 Aug 2025 11:58:28 +0200 Subject: [PATCH 23/36] fixed teffX and lumX to temperatureX and luminosityX for X in {1,2} --- ...dard-logfiles-record-specification-binary.rst | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/online-docs/pages/User guide/COMPAS output/standard-logfiles-record-specification-binary.rst b/online-docs/pages/User guide/COMPAS output/standard-logfiles-record-specification-binary.rst index 79c7b1095..18b7541b0 100644 --- a/online-docs/pages/User guide/COMPAS output/standard-logfiles-record-specification-binary.rst +++ b/online-docs/pages/User guide/COMPAS output/standard-logfiles-record-specification-binary.rst @@ -800,7 +800,7 @@ Binary Properties * - Data type: - DOUBLE * - COMPAS variable: - - BaseBinaryStar::m_RLOFDetails.propsPostMT→lum1 + - BaseBinaryStar::m_RLOFDetails.propsPostMT→luminosity1 * - Description: - Luminosity (\ :math:`L_\odot`) of the primary immediately after RLOF. * - Header String: @@ -816,7 +816,7 @@ Binary Properties * - Data type: - DOUBLE * - COMPAS variable: - - BaseBinaryStar::m_RLOFDetails.propsPostMT→lum2 + - BaseBinaryStar::m_RLOFDetails.propsPostMT→luminosity2 * - Description: - Luminosity (\ :math:`L_\odot`) of the secondary immediately after RLOF. * - Header String: @@ -896,7 +896,7 @@ Binary Properties * - Data type: - DOUBLE * - COMPAS variable: - - BaseBinaryStar::m_RLOFDetails.propsPostMT→teff1 + - BaseBinaryStar::m_RLOFDetails.propsPostMT→temperature1 * - Description: - Effective temperature (\ :math:`K`) of the primary immediately after RLOF. * - Header String: @@ -912,7 +912,7 @@ Binary Properties * - Data type: - DOUBLE * - COMPAS variable: - - BaseBinaryStar::m_RLOFDetails.propsPostMT→teff2 + - BaseBinaryStar::m_RLOFDetails.propsPostMT→temperature2 * - Description: - Effective temperature (\ :math:`K`) of the secondary immediately after RLOF. * - Header String: @@ -1100,7 +1100,7 @@ but not both. If both are printed then the file will contain two columns with th * - Data type: - DOUBLE * - COMPAS variable: - - BaseBinaryStar::m_RLOFDetails.propsPreMT→lum1 + - BaseBinaryStar::m_RLOFDetails.propsPreMT→luminosity1 * - Description: - Luminosity (\ :math:`L_\odot`) of the primary at the onset of RLOF. * - Header String: @@ -1116,7 +1116,7 @@ but not both. If both are printed then the file will contain two columns with th * - Data type: - DOUBLE * - COMPAS variable: - - BaseBinaryStar::m_RLOFDetails.propsPreMT→lum2 + - BaseBinaryStar::m_RLOFDetails.propsPreMT→luminosity2 * - Description: - Luminosity (\ :math:`L_\odot`) of the secondary at the onset of RLOF. * - Header String: @@ -1197,7 +1197,7 @@ but not both. If both are printed then the file will contain two columns with th * - Data type: - DOUBLE * - COMPAS variable: - - BaseBinaryStar::m_RLOFDetails.propsPreMT→teff1 + - BaseBinaryStar::m_RLOFDetails.propsPreMT→temperature1 * - Description: - Effective temperature (\ :math:`K`) of the primary at the onset of RLOF. * - Header String: @@ -1213,7 +1213,7 @@ but not both. If both are printed then the file will contain two columns with th * - Data type: - DOUBLE * - COMPAS variable: - - BaseBinaryStar::m_RLOFDetails.propsPreMT→teff2 + - BaseBinaryStar::m_RLOFDetails.propsPreMT→temperature2 * - Description: - Effective temperature (\ :math:`K`) of the secondary at the onset of RLOF. * - Header String: From 89338e9b8c40a624f5d0902294d54daf97c2e9db Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Mon, 18 Aug 2025 12:01:27 +0200 Subject: [PATCH 24/36] forgot to update version in changelog --- src/changelog.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/changelog.h b/src/changelog.h index 19a87a718..9a683b7fd 100644 --- a/src/changelog.h +++ b/src/changelog.h @@ -1664,7 +1664,7 @@ // if MM is incremented, set mm and rr to 00, even if defect repairs and minor enhancements were also made // if mm is incremented, set rr to 00, even if defect repairs were also made -const std::string VERSION_STRING = "03.23.01"; +const std::string VERSION_STRING = "03.23.02"; # endif // __changelog_h__ From a89d9b905375c74bbaa3711ddd5f381fab9665f8 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Mon, 18 Aug 2025 12:13:26 +0200 Subject: [PATCH 25/36] new program options for maltsev model --- .../program-options-list-defaults.rst | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/online-docs/pages/User guide/Program options/program-options-list-defaults.rst b/online-docs/pages/User guide/Program options/program-options-list-defaults.rst index 919044783..87c7757d4 100644 --- a/online-docs/pages/User guide/Program options/program-options-list-defaults.rst +++ b/online-docs/pages/User guide/Program options/program-options-list-defaults.rst @@ -818,6 +818,20 @@ Options: {ZERO, MANDEL, BRCEK} |br| ``BRCEK`` : Core mass according to Shikauchi et al. (2024) with added rejuvenation of MS accretors and updated stellar tracks |br| Default = MANDEL +**--maltsev-fallback** |br| +Fixed fallback fraction when using MALTSEV2024 remnant mass prescription (must be between 0 and 1). |br| +A value of 0.0 means that fallback BHs get no fallback, only the mass of the proto-NS remnant (and will get flagged as NSs). |br| +A value of 1.0 means that fallback BHs get total fallback, taking the mass of the progenitor up to and including the He core (but not the H envelope). |br| +Default = 0.5 + +**--maltsev-mode** |br| +Which variant of the MALTSEV remnant mass prescription. Variants pertain to the treatment of extrapolation at low metallicities, and are described in detail in Willcox+ 2025. |br| +Options: {OPTIMISTIC, BALANCED, PESSIMISTIC} |br| +``OPTIMISTIC`` : Compactness-peak BHs formed from the lowest CO-mass progenitors for a given metallicity. |br| +``PESSIMISTIC`` : Compactness-peak BHs only formed from the highest CO-mass progenitors for a given metallicity. |br| +``BALANCED`` : Compactness-peak BHs formed CO-mass progenitors with masses between the two previous extremes for a given metallicity. |br| +Default = BALANCED + **--mass-change-fraction** |br| Approximate desired fractional change in stellar mass on phase when setting SSE and BSE timesteps (applied before ``--timestep--multiplier``). |br| Recommended value is 0.005. |br| From fbebc9c5f0e9ce82c68cbce1c55222727866cb16 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Mon, 18 Aug 2025 13:14:34 +0200 Subject: [PATCH 26/36] cleaned up MALTSEV treatment of NS masses, now all are the canonical NS mass --- src/GiantBranch.cpp | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index e820514ec..31cb6dea1 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1308,7 +1308,7 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, if (utils::Compare(p_COCoreMass, MALTSEV2024_MMIN) < 0) { // NS formation regardless of metallicity and MT history m_SupernovaDetails.fallbackFraction = 0; - remnantMass = 1.35; //CalculateRemnantNSMassMullerMandel(p_COCoreMass, p_HeCoreMass); + remnantMass = NEUTRON_STAR_MASS; } else if (utils::Compare(p_COCoreMass, MALTSEV2024_MMAX) > 0) { // BH formation regardless of metallicity and MT history m_SupernovaDetails.fallbackFraction = 1; @@ -1388,20 +1388,19 @@ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, THROW_ERROR(ERROR::UNKNOWN_MT_CASE); // throw error } + if( utils::Compare(p_COCoreMass, M3) >=0 || (utils::Compare(p_COCoreMass, M1) >= 0 && utils::Compare(p_COCoreMass, M2) <= 0) ) { // Complete fallback into BH - remnantMass = p_HeCoreMass; m_SupernovaDetails.fallbackFraction = 1; + remnantMass = p_HeCoreMass; } else if ( utils::Compare(p_COCoreMass, M2) > 0 && utils::Compare(p_COCoreMass, M3) < 0 && utils::Compare(RAND->Random(0, 1), 0.1) <= 0 ) { // Partial fallback BH formation // add fallback back on m_SupernovaDetails.fallbackFraction = OPTIONS->MaltsevFallback(); - double mhe = m_SupernovaDetails.HeCoreMassAtCOFormation; - double mns = 1.44; - remnantMass = mns + (mhe - mns) *m_SupernovaDetails.fallbackFraction; + remnantMass = (p_HeCoreMass - NEUTRON_STAR_MASS)*m_SupernovaDetails.fallbackFraction + NEUTRON_STAR_MASS; } else { m_SupernovaDetails.fallbackFraction = 0; - remnantMass = 1.40; // slightly lower mass NS - just to distinguish it... + remnantMass = NEUTRON_STAR_MASS; } } return remnantMass; From 7672fdacd4de24ee961c584cfd9125c8ac77c15f Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Mon, 18 Aug 2025 13:32:08 +0200 Subject: [PATCH 27/36] yaml --- src/yaml.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/yaml.h b/src/yaml.h index b93d44047..3aa748e5c 100644 --- a/src/yaml.h +++ b/src/yaml.h @@ -349,6 +349,8 @@ namespace yaml { " --fryer-supernova-engine", " --kick-magnitude-distribution", " --kick-direction-distribution", + " --maltsev-fallback", + " --maltsev-mode", " --neutron-star-accretion-in-ce", " --neutron-star-equation-of-state", " --neutrino-mass-loss-BH-formation", From 32340364ab0221b6555d921fb56d3db4099f1e12 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Mon, 18 Aug 2025 13:38:29 +0200 Subject: [PATCH 28/36] yaml --- compas_python_utils/preprocessing/compasConfigDefault.yaml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/compas_python_utils/preprocessing/compasConfigDefault.yaml b/compas_python_utils/preprocessing/compasConfigDefault.yaml index 82ba3ad85..e46a0e853 100644 --- a/compas_python_utils/preprocessing/compasConfigDefault.yaml +++ b/compas_python_utils/preprocessing/compasConfigDefault.yaml @@ -1,5 +1,5 @@ ##~!!~## COMPAS option values -##~!!~## File Created Sun Aug 10 13:16:13 2025 by COMPAS v03.23.00 +##~!!~## File Created Mon Aug 18 13:37:46 2025 by COMPAS v03.23.02 ##~!!~## ##~!!~## The default COMPAS YAML file (``compasConfigDefault.yaml``), as distributed, has ##~!!~## all COMPAS option entries commented so that the COMPAS default value for the @@ -283,6 +283,8 @@ stringChoices: # --fryer-supernova-engine: 'DELAYED' # Default: 'DELAYED' # Options: ['DELAYED','RAPID'] # --kick-magnitude-distribution: 'MULLERMANDEL' # Default: 'MULLERMANDEL' # Options: ['LOGNORMAL','MULLERMANDEL','MULLER2016MAXWELLIAN','MULLER2016','BRAYELDRIDGE','MAXWELLIAN','FLAT','FIXED','ZERO'] # --kick-direction-distribution: 'ISOTROPIC' # Default: 'ISOTROPIC' # Options: ['POLES','WEDGE','POWERLAW','PERPENDICULAR','INPLANE','ISOTROPIC'] +# --maltsev-fallback: 0.500000 # Default: 0.500000 +# --maltsev-mode: 'BALANCED' # Default: 'BALANCED' # Options: ['PESSIMISTIC','BALANCED','OPTIMISTIC'] # --neutron-star-accretion-in-ce: 'ZERO' # Default: 'ZERO' # Options: ['DISK','SURFACE','ZERO'] # --neutron-star-equation-of-state: 'SSE' # Default: 'SSE' # Options: ['ARP3','SSE'] # --neutrino-mass-loss-BH-formation: 'FIXED_MASS' # Default: 'FIXED_MASS' # Options: ['FIXED_MASS','FIXED_FRACTION'] From 218eb555c6aa94bb255e6e930e4b1c3bf183b20c Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Mon, 18 Aug 2025 13:39:00 +0200 Subject: [PATCH 29/36] teff -> temperature, lum -> luminosity --- src/BaseBinaryStar.cpp | 24 ++++++++++++------------ src/typedefs.h | 8 ++++---- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/src/BaseBinaryStar.cpp b/src/BaseBinaryStar.cpp index fa502f712..d9b498dd5 100644 --- a/src/BaseBinaryStar.cpp +++ b/src/BaseBinaryStar.cpp @@ -572,10 +572,10 @@ COMPAS_VARIABLE BaseBinaryStar::BinaryPropertyValue(const T_ANY_PROPERTY p_Prope case BINARY_PROPERTY::RLOF_POST_MT_STAR2_MASS: value = RLOFDetails().propsPostMT->mass2; break; case BINARY_PROPERTY::RLOF_POST_MT_STAR1_RADIUS: value = RLOFDetails().propsPostMT->radius1; break; case BINARY_PROPERTY::RLOF_POST_MT_STAR2_RADIUS: value = RLOFDetails().propsPostMT->radius2; break; - case BINARY_PROPERTY::RLOF_POST_MT_STAR1_TEFF: value = RLOFDetails().propsPostMT->teff1; break; - case BINARY_PROPERTY::RLOF_POST_MT_STAR2_TEFF: value = RLOFDetails().propsPostMT->teff2; break; - case BINARY_PROPERTY::RLOF_POST_MT_STAR1_LUM: value = RLOFDetails().propsPostMT->lum1; break; - case BINARY_PROPERTY::RLOF_POST_MT_STAR2_LUM: value = RLOFDetails().propsPostMT->lum2; break; + case BINARY_PROPERTY::RLOF_POST_MT_STAR1_TEFF: value = RLOFDetails().propsPostMT->temperature1; break; + case BINARY_PROPERTY::RLOF_POST_MT_STAR2_TEFF: value = RLOFDetails().propsPostMT->temperature2; break; + case BINARY_PROPERTY::RLOF_POST_MT_STAR1_LUM: value = RLOFDetails().propsPostMT->luminosity1; break; + case BINARY_PROPERTY::RLOF_POST_MT_STAR2_LUM: value = RLOFDetails().propsPostMT->luminosity2; break; case BINARY_PROPERTY::RLOF_POST_MT_STAR1_RLOF: value = RLOFDetails().propsPostMT->isRLOF1; break; case BINARY_PROPERTY::RLOF_POST_MT_STAR2_RLOF: value = RLOFDetails().propsPostMT->isRLOF2; break; case BINARY_PROPERTY::RLOF_POST_MT_STAR1_STELLAR_TYPE: value = RLOFDetails().propsPostMT->stellarType1; break; @@ -590,10 +590,10 @@ COMPAS_VARIABLE BaseBinaryStar::BinaryPropertyValue(const T_ANY_PROPERTY p_Prope case BINARY_PROPERTY::RLOF_PRE_MT_STAR2_MASS: value = RLOFDetails().propsPreMT->mass2; break; case BINARY_PROPERTY::RLOF_PRE_MT_STAR1_RADIUS: value = RLOFDetails().propsPreMT->radius1; break; case BINARY_PROPERTY::RLOF_PRE_MT_STAR2_RADIUS: value = RLOFDetails().propsPreMT->radius2; break; - case BINARY_PROPERTY::RLOF_PRE_MT_STAR1_TEFF: value = RLOFDetails().propsPreMT->teff1; break; - case BINARY_PROPERTY::RLOF_PRE_MT_STAR2_TEFF: value = RLOFDetails().propsPreMT->teff2; break; - case BINARY_PROPERTY::RLOF_PRE_MT_STAR1_LUM: value = RLOFDetails().propsPreMT->lum1; break; - case BINARY_PROPERTY::RLOF_PRE_MT_STAR2_LUM: value = RLOFDetails().propsPreMT->lum2; break; + case BINARY_PROPERTY::RLOF_PRE_MT_STAR1_TEFF: value = RLOFDetails().propsPreMT->temperature1; break; + case BINARY_PROPERTY::RLOF_PRE_MT_STAR2_TEFF: value = RLOFDetails().propsPreMT->temperature2; break; + case BINARY_PROPERTY::RLOF_PRE_MT_STAR1_LUM: value = RLOFDetails().propsPreMT->luminosity1; break; + case BINARY_PROPERTY::RLOF_PRE_MT_STAR2_LUM: value = RLOFDetails().propsPreMT->luminosity2; break; case BINARY_PROPERTY::RLOF_PRE_MT_STAR1_RLOF: value = RLOFDetails().propsPreMT->isRLOF1; break; case BINARY_PROPERTY::RLOF_PRE_MT_STAR2_RLOF: value = RLOFDetails().propsPreMT->isRLOF2; break; case BINARY_PROPERTY::RLOF_PRE_MT_STAR1_STELLAR_TYPE: value = RLOFDetails().propsPreMT->stellarType1; break; @@ -914,10 +914,10 @@ void BaseBinaryStar::StashRLOFProperties(const MT_TIMING p_Which) { rlofPropertiesToReset->massLossRateFromDonor = m_MassLossRateInRLOF; rlofPropertiesToReset->accretionEfficiency = m_FractionAccreted; rlofPropertiesToReset->massTransferTimescale = m_MassTransferTimescale; - rlofPropertiesToReset->teff1 = m_Star1->Temperature(); - rlofPropertiesToReset->teff2 = m_Star2->Temperature(); - rlofPropertiesToReset->lum1 = m_Star1->Luminosity(); - rlofPropertiesToReset->lum2 = m_Star2->Luminosity(); + rlofPropertiesToReset->temperature1 = m_Star1->Temperature(); + rlofPropertiesToReset->temperature2 = m_Star2->Temperature(); + rlofPropertiesToReset->luminosity1 = m_Star1->Luminosity(); + rlofPropertiesToReset->luminosity2 = m_Star2->Luminosity(); } diff --git a/src/typedefs.h b/src/typedefs.h index 17cf6be3a..0b6bc1dc3 100755 --- a/src/typedefs.h +++ b/src/typedefs.h @@ -1210,10 +1210,10 @@ typedef struct RLOFProperties { double radius1; double radius2; - double teff1; - double teff2; - double lum1; - double lum2; + double temperature1; + double temperature2; + double luminosity1; + double luminosity2; double starToRocheLobeRadiusRatio1; double starToRocheLobeRadiusRatio2; From 409982c18632e584102fa30b19898ad643ad7882 Mon Sep 17 00:00:00 2001 From: jeffriley Date: Tue, 19 Aug 2025 17:10:25 +1000 Subject: [PATCH 30/36] Update GiantBranch.cpp - formatting --- src/GiantBranch.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index 31cb6dea1..e21cc3bbf 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1953,19 +1953,18 @@ STELLAR_TYPE GiantBranch::ResolveCoreCollapseSN() { case REMNANT_MASS_PRESCRIPTION::SCHNEIDER2020: // Schneider 2020 m_Mass = CalculateRemnantMassBySchneider2020(m_COCoreMass); - m_SupernovaDetails.fallbackFraction = utils::Compare(m_Mass, OPTIONS->MaximumNeutronStarMass() ) > 0 ? (m_Mass - NEUTRON_STAR_MASS) / (mass - NEUTRON_STAR_MASS) : 0.0; // Fallback fraction of mass beyond proto-neutron-star for BH formation and kicks + m_SupernovaDetails.fallbackFraction = utils::Compare(m_Mass, OPTIONS->MaximumNeutronStarMass() ) > 0 ? (m_Mass - NEUTRON_STAR_MASS) / (mass - NEUTRON_STAR_MASS) : 0.0; // fallback fraction of mass beyond proto-neutron-star for BH formation and kicks break; case REMNANT_MASS_PRESCRIPTION::SCHNEIDER2020ALT: // Schneider 2020, alternative m_Mass = CalculateRemnantMassBySchneider2020Alt(m_COCoreMass); - m_SupernovaDetails.fallbackFraction = utils::Compare(m_Mass, OPTIONS->MaximumNeutronStarMass() ) > 0 ? (m_Mass - NEUTRON_STAR_MASS) / (mass - NEUTRON_STAR_MASS) : 0.0; // Fallback fraction of mass beyond proto-neutron-star for BH formation and kicks + m_SupernovaDetails.fallbackFraction = utils::Compare(m_Mass, OPTIONS->MaximumNeutronStarMass() ) > 0 ? (m_Mass - NEUTRON_STAR_MASS) / (mass - NEUTRON_STAR_MASS) : 0.0; // fallback fraction of mass beyond proto-neutron-star for BH formation and kicks break; case REMNANT_MASS_PRESCRIPTION::MALTSEV2024: // Maltsev+ 2024 - //fallback fraction determined internally - m_Mass = CalculateRemnantMassByMaltsev2024(m_COCoreMass, m_HeCoreMass); + m_Mass = CalculateRemnantMassByMaltsev2024(m_COCoreMass, m_HeCoreMass); // fallback fraction determined internally break; From d1c33d6590e74582352f4b48113fafc30dab6bd8 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Tue, 19 Aug 2025 09:20:48 +0200 Subject: [PATCH 31/36] changelog --- src/changelog.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/changelog.h b/src/changelog.h index 9a683b7fd..cd4eb1329 100644 --- a/src/changelog.h +++ b/src/changelog.h @@ -1650,7 +1650,7 @@ // 03.23.01 IM - August 18, 2025 - Enhancement, defect repair: // - In the MALTSEV SN prescription, treat wind-stripped stars as if they experienced case B mass transfer // - Limit the output of CalculateEtaPTY() [Helium accretion efficiency onto WDs from Piersanti+ 2014, A3] to be in [0,1] -// 03.23.02 RTW - August 18, 2025 - Enhancement: +// 03.24.00 RTW - August 18, 2025 - Enhancement: // - Updated Maltsev SN prescription, to include Maltsev mode (extrapolation variant outside of Z bounds), // fallback option, fixed remnant mass, and added lum and teff as attributes of RLOFProperties // @@ -1664,7 +1664,7 @@ // if MM is incremented, set mm and rr to 00, even if defect repairs and minor enhancements were also made // if mm is incremented, set rr to 00, even if defect repairs were also made -const std::string VERSION_STRING = "03.23.02"; +const std::string VERSION_STRING = "03.24.00"; # endif // __changelog_h__ From 02e624d20285449857923dd52ca15a31f4c302a5 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Tue, 19 Aug 2025 09:22:21 +0200 Subject: [PATCH 32/36] added constexpr and description of M1, M2, M3 for PR --- src/GiantBranch.cpp | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/GiantBranch.cpp b/src/GiantBranch.cpp index 31cb6dea1..911ca7891 100644 --- a/src/GiantBranch.cpp +++ b/src/GiantBranch.cpp @@ -1297,13 +1297,13 @@ double GiantBranch::CalculateRemnantMassBySchneider2020(const double p_COCoreMas */ double GiantBranch::CalculateRemnantMassByMaltsev2024(const double p_COCoreMass, const double p_HeCoreMass) { - ST_VECTOR mtHist = MassTransferDonorHistory(); // mass transfer history vector - MT_CASE massTransferCase = MT_CASE::OTHER; - double log10Z = m_Log10Metallicity - LOG10_ZSOL_ASPLUND; // log_{10} (Z/Zsol), for convenience - double log10_1 = 0; // useful for the limits later - double log10_1_div_10 = -1; // useful for the limits later - double log10_1_div_50 = -1.69897; // useful for the limits later - double M1, M2, M3; + ST_VECTOR mtHist = MassTransferDonorHistory(); // mass transfer history vector + MT_CASE massTransferCase = MT_CASE::OTHER; + double log10Z = m_Log10Metallicity - LOG10_ZSOL_ASPLUND; // log_{10} (Z/Zsol), for convenience + constexpr double log10_1 = 0; // useful for the limits later + constexpr double log10_1_div_10 = -1; // useful for the limits later + constexpr double log10_1_div_50 = -1.69897; // useful for the limits later + double M1, M2, M3; // Z-dependent boundary values for SN outcomes (see Maltsev+ 2025) double remnantMass; if (utils::Compare(p_COCoreMass, MALTSEV2024_MMIN) < 0) { // NS formation regardless of metallicity and MT history From 5202288ff4ba303d3ec7542e13895b2e6c9eec87 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Tue, 19 Aug 2025 09:24:21 +0200 Subject: [PATCH 33/36] what's new --- online-docs/pages/whats-new.rst | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/online-docs/pages/whats-new.rst b/online-docs/pages/whats-new.rst index c3a2e8dc4..aaa62eeee 100644 --- a/online-docs/pages/whats-new.rst +++ b/online-docs/pages/whats-new.rst @@ -3,6 +3,10 @@ What's new Following is a brief list of important updates to the COMPAS code. A complete record of changes can be found in the file ``changelog.h``. +**03.24.00 August 19, 2025** + +* Updated Maltsev remnant mass prescription to include the 3 variants described in Willcox+ 2025 (bimodality paper). + **03.23.00 August 09, 2025** * The following option is now deprecated, and will be removed in 1 year: From ed178fb049fb335fe56487c8cf27cf693cdc6fda Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Tue, 19 Aug 2025 10:17:08 +0200 Subject: [PATCH 34/36] what's new, more detail --- online-docs/pages/whats-new.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/online-docs/pages/whats-new.rst b/online-docs/pages/whats-new.rst index aaa62eeee..98590677b 100644 --- a/online-docs/pages/whats-new.rst +++ b/online-docs/pages/whats-new.rst @@ -6,6 +6,8 @@ Following is a brief list of important updates to the COMPAS code. A complete r **03.24.00 August 19, 2025** * Updated Maltsev remnant mass prescription to include the 3 variants described in Willcox+ 2025 (bimodality paper). +* New related options `--maltsev-fallback` which takes a float between 0 and 1 to specify the fallback fraction, and + `--maltsev-mode` with choices `'OPTIMISTIC','PESSIMISTIC','BALANCED'` for the extrapolation prescription (see Willcox+ 2025b) **03.23.00 August 09, 2025** From e9f46820bc19b3c6f560f3e1fda5655a022bafb2 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Tue, 19 Aug 2025 14:59:09 +0200 Subject: [PATCH 35/36] typo --- .../Program options/program-options-list-defaults.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/online-docs/pages/User guide/Program options/program-options-list-defaults.rst b/online-docs/pages/User guide/Program options/program-options-list-defaults.rst index 87c7757d4..4f1765d80 100644 --- a/online-docs/pages/User guide/Program options/program-options-list-defaults.rst +++ b/online-docs/pages/User guide/Program options/program-options-list-defaults.rst @@ -829,7 +829,7 @@ Which variant of the MALTSEV remnant mass prescription. Variants pertain to the Options: {OPTIMISTIC, BALANCED, PESSIMISTIC} |br| ``OPTIMISTIC`` : Compactness-peak BHs formed from the lowest CO-mass progenitors for a given metallicity. |br| ``PESSIMISTIC`` : Compactness-peak BHs only formed from the highest CO-mass progenitors for a given metallicity. |br| -``BALANCED`` : Compactness-peak BHs formed CO-mass progenitors with masses between the two previous extremes for a given metallicity. |br| +``BALANCED`` : Compactness-peak BHs formed from CO-mass progenitors with masses between the two previous extremes for a given metallicity. |br| Default = BALANCED **--mass-change-fraction** |br| From a9708a80c62b8ed4c87cafdc1bc4b2c231de4388 Mon Sep 17 00:00:00 2001 From: Reinhold Willcox Date: Tue, 19 Aug 2025 15:00:53 +0200 Subject: [PATCH 36/36] typo --- .../Program options/program-options-list-defaults.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/online-docs/pages/User guide/Program options/program-options-list-defaults.rst b/online-docs/pages/User guide/Program options/program-options-list-defaults.rst index 4f1765d80..46d869620 100644 --- a/online-docs/pages/User guide/Program options/program-options-list-defaults.rst +++ b/online-docs/pages/User guide/Program options/program-options-list-defaults.rst @@ -825,7 +825,7 @@ A value of 1.0 means that fallback BHs get total fallback, taking the mass of th Default = 0.5 **--maltsev-mode** |br| -Which variant of the MALTSEV remnant mass prescription. Variants pertain to the treatment of extrapolation at low metallicities, and are described in detail in Willcox+ 2025. |br| +Choice of which variant for the MALTSEV remnant mass prescription. Variants pertain to the treatment of extrapolation at low metallicities, and are described in detail in Willcox+ 2025. |br| Options: {OPTIMISTIC, BALANCED, PESSIMISTIC} |br| ``OPTIMISTIC`` : Compactness-peak BHs formed from the lowest CO-mass progenitors for a given metallicity. |br| ``PESSIMISTIC`` : Compactness-peak BHs only formed from the highest CO-mass progenitors for a given metallicity. |br|