![]() |
SEVN
|
#include <property.h>
Public Types | |
| typedef std::map< std::string, size_t > | _PrintMap |
Public Member Functions | |
| Lambda (bool reg=true) | |
| Lambda * | Instance () override |
| std::string | name () const override |
| std::string | units () override |
| void | set_remnant (_UNUSED Star *s) override |
| void | evolve_remnant (_UNUSED Star *s) override |
| void | evolve_nakedco (_UNUSED Star *s) override |
| double | get (_UNUSED const Star *s=NULL) override |
| void | evolve (_UNUSED Star *s) override |
| void | update_from_binary (_UNUSED Star *s, _UNUSED const double &DV, _UNUSED Binstar *b) override |
| virtual void | update_from_binary (_UNUSED Star *s, const double &DV, _UNUSED Binstar *b=nullptr) |
| void | set_empty (_UNUSED Star *s) override |
| void | evolve_empty (_UNUSED Star *s) override |
| void | update_derived (_UNUSED Star *s) override |
| virtual void | restore () override |
| virtual void | synch () override |
| double | get_fk (_UNUSED const Star *s=NULL) override |
| double | get_0_fk (_UNUSED const Star *s=NULL) override |
| double | get_0 (_UNUSED const Star *s=NULL) override |
| virtual void | copy_V_from (Property *p) |
| virtual void | resynch (_UNUSED const double &dt, _UNUSED bool set0=true) |
| virtual void | resynch (_UNUSED Star *s) |
| virtual void | set_empty_in_bse (_UNUSED Star *s, _UNUSED Binstar *b) |
| virtual void | set_remnant_in_bse (_UNUSED Star *s, _UNUSED Binstar *b) |
| virtual size_t | TabID () |
| virtual void | special_evolve (_UNUSED Star *s) |
| virtual void | evolve_fake (Star *s) |
| virtual void | init (_UNUSED const double &a) |
| virtual void | evolve_real () |
| virtual void | update_variation () |
| virtual void | correct_interpolation_errors (_UNUSED Star *s) |
| virtual void | correct_interpolation_errors_real (_UNUSED Star *s) |
| virtual void | reset () |
| virtual void | changed_track (_UNUSED Star *s, _UNUSED Star *s_jtrack) |
| double | get_fk_raw (_UNUSED const Star *s=NULL) const |
| double | get_0_fk_raw (_UNUSED const Star *s=NULL) const |
| double | get_raw (_UNUSED const Star *s=NULL) const |
| double | get_0_raw (_UNUSED const Star *s=NULL) const |
| virtual double | get_Vlast (_UNUSED const Star *s) const |
| double * | get_wm () |
| double * | get_wz () |
| virtual void | set_w (_UNUSED Star *s) |
| virtual bool | are_table_loaded () const |
| virtual void | set_refpointers (_UNUSED Star *s) |
Static Public Member Functions | |
| static size_t | size () |
Public Attributes | |
| double * | val_ref [4] |
| double * | val_in [4] |
Static Public Attributes | |
| static size_t | ID |
| static Lambda | _lambda |
| static _PrintMap | PrintMap |
| static vector< Property * > | all |
Protected Member Functions | |
| double | estimate_lambda (const Star *star) |
| bool | new_estimate_needed () |
| void | set (const double &a) override |
| void | set_fk (const double &a) |
| void | set_0_fk (const double &a) |
| virtual void | set_0 (const double &a) |
| void | set_VBIN (const size_t &id, const double &a) |
| virtual void | safety_check () |
| void | Register (Property *_p, size_t *id, const std::string &_name) |
Protected Attributes | |
| double | value |
| double | value0 |
| double | Dvalue |
| double | V |
| double | V0 |
| vector< double > | VBIN |
| double | interpolating_values [4] |
| double | wM [4] |
| double | wZ [2] |
| SevnLogging | svlog |
Static Protected Attributes | |
| static size_t | _size = 0 |
Private Member Functions | |
| double | estimate_lambda_BSE (const Star *star, bool whole_cenv=false, bool m0_as_hurley=false) |
| double | estimate_lambda_Parsec (const Star *star) |
| double | estimate_lambda_Claeys14 (const Star *star, bool whole_cenv=false) |
| double | estimate_lambda_Izzard04 (const Star *star, bool whole_cenv=false) |
| double | estimate_lambda_Klencki21 (const Star *star, bool interpolate=false) |
| double | estimate_lambda_Nanjing (const Star *star, bool interpolate=false) |
| double | get_M0_BSE (const Star *s) |
| double | get_Rzams (const Star *s) |
| void | copy_V_from (_UNUSED Property *p) override |
| virtual bool | amiderived () |
Private Attributes | |
| double | Mzams_cachedM =0 |
| double | Zmet_cachedM =0 |
| double | M0_cached =0 |
| double | Mzams_cachedR =0 |
| double | Zmet_cachedR =0 |
| double | Rzams_cached =0 |
| bool | first_call =true |
| std::unique_ptr< Lambda_Base > | lambda_base_ptr |
| unsigned int | last_evolve_number =0 |
| unsigned int | evolve_number =0 |
|
inherited |
|
inline |
|
inlineprivatevirtualinherited |
Check if this is a derived. A property is defined dervied if it is estimated by the combination of other properties and it is not the derivative of a property.
Reimplemented from Property.
|
inlinevirtualinherited |
Reimplemented in TableProperty.
|
inlinevirtualinherited |
Handle the modification of the property after a track change. It does nothing by default.
| s | The star for which we are changing the tracks. |
| s_jtrack | The star that we are using to get info of the new tracks. |
Reimplemented in Localtime, Timestep, Radius, Mass, MHE, MCO, Phase, Luminosity, Inertia, RHE, RCO, Hsup, HEsup, Csup, Nsup, Osup, Qconv, Tconv, Depthconv, dMcumul_binary, AngMomSpin, and Temperature.
Disable copy
| p |
|
inlinevirtualinherited |
Reimplemented in R_object, and Mass_obejct.
|
protected |
Estimate the lambda for a given star. The binding energy of an envelope is Ebind = Integrate^Mtot_Mcore dM - G M(r)/r + alpha_th*U, where U is the internal energy and alpha_th a fraction of internal energy used to unbound the envelope. For simplicity we can write Ebind_s = -G Mtot Menv / lambda R, where lambda is the factor for which Ebind_s=Ebind. Usually, the lambda is taken between two extrema: lambda_g obtained considering only the gravitational energy (alpha_th=0) and lambda_b obtained consider a fully efficiency of the internal energy in unbounding the envelope (alpha_th=1). The implementation depends on the Common envelope models and common envelope parameters
| star | Star for which we want to estimate the binding energy |
|
private |
Estimate lambda following exactly the implementation of lambda in Mobse The mass fraction of the convective envelope over the whole envelope will be used
| star | Star for which we want to estimate the binding energy |
| whole_cenv | If true conside that all the envelope is convective |
Initial checks
Start Estimate
The final lambda depends on the fraction of the mass convective envelope over the total envelope mass. If we are using convective tables just use the table value, otherwise estimate the Mcenv using analytic approximation from Hurley (see Qconv::estimate_without_table) fcenv=Qconv, If whole_cenv is true consider the whole envelope as convective fcenv=1
|
private |
Estimate lambda following Claeys+14 (Appendix A, https://www.aanda.org/articles/aa/pdf/2014/03/aa22714-13.pdf) The mass of the convective envelope in Msun will be used
| star | Star for which we want to estimate the binding energy |
| whole_cenv | If true conside that all the envelope is convective |
Initial checks
Start Estimate
The final lambda depends on the Mass of the convective envelope. If we are using convective tables just use the table value, otherwise estimate the Mcenv using analytic approximation from Hurley (see Qconv::estimate_without_table) Mcenv_env=Qconv*Mass, If whole_cenv is true consider the whole envelope as convective
Estimate lam2 (needed only for Mcenv<1)
Estimate lam1 (needed only for Mcenv>0)
Estimate ionization contribution //Eq. A6
Final lambda_ce estimate //Eq. A1 without 2, see comment above
|
private |
Estimate lambda following Izzard+04 (Appendix E, http://personal.ph.surrey.ac.uk/~ri0005/doc/thesis/thesis.pdf), it is similar to Claeys+14, but lambda1 is multiplied by 2 before to add the correction for the ionization terms The mass of the convective envelope in Msun will be used
| star | Star for which we want to estimate the binding energy |
| whole_cenv | If true conside that all the envelope is convective |
Initial checks
Start Estimate
The final lambda depends on the Mass of the convective envelope. If we are using convective tables just use the table value, otherwise estimate the Mcenv using analytic approximation from Hurley (see Qconv::estimate_without_table) Mcenv_env=Qconv*Mass, If whole_cenv is true consider the whole envelope as convective
Estimate lam2 (needed only for Mcenv<1)
Estimate lam1 (needed only for Mcenv>0)
Multiply by 2
Estimate ionization contribution //Eq. A6
Final lambda_ce estimate //Eq. A1 without 2, see comment above
|
private |
Estimate lambda using tables from Klencki+21 The Lambda fit comes from Appendix A in Klencki+21 (https://ui.adsabs.harvard.edu/abs/2021A%26A...645A..54K/abstract). Lambda is thus estimated as: log10(lambda) = a*x^3 + b*x^2 + c*x + d where x=log10(R) The value of a,b,c,d depends on the Mass (Mzams), Z (metallicity) and Radius.
| star | Pointer to the star |
| interpolate | if true, estimate lambda interpolating between lambdas for tracks in Klencki+21 tables if false, use a quantised formalism, i.e. for a Mzams and a Z not present in the table, the closed track with Mtrack>Mzams and Ztrack>Z. If Mzams<10, Mtracks=10 is used, for Z/Zsun<0.01, Z/Zsun=0.01 is used. |
|
private |
Estimate Lambda using fitting equations from the work of Xi&Liu10 (https://iopscience.iop.org/article/10.1088/0004-637X/716/1/114) + its errata corrige (https://iopscience.iop.org/article/10.1088/0004-637X/722/2/1985). The implementation is taken directly from the COMPAS code https://github.com/TeamCOMPAS/COMPAS that is based on the STARTRACK implementation (see Dominik+12, https://ui.adsabs.harvard.edu/abs/2012ApJ...759...52D/abstract). Lambda is thus estimated as:
y = a + b1*x + b2*x^2 + b3+*x^3 + b4*x^4 + b5*x^5 where y is in general lambda (gravitational or considering also the thermal energy), sometime it is 1/lambda or sometime it is log lambda. x in general is the Radius, but sometime it is the mass of the envelope.
| star | Pointer to the star |
| interpolate | if true, estimate lambda interpolating between lambdas for tracks in Xu&Lu10 if false, use a quantised formalism, i.e. for a Mzams not in the table use, the closed track with Mtrack>Mzams and Ztrack>Z. |
|
private |
Estimate lambda from the Parsec tracks. This is an experimental function based on the first results of Mario and her student. At the moment we use a very super preliminary results: it seems that expect for the very last stellar phase, the lambda estimated from Parsec tracks is a scaled (0.1) version of Claeys et al. 2014 (Appendix A)
| star | Star for which we want to estimate the binding energy |
Reimplemented from Property.
|
virtualinherited |
Set v0=v
Move to new value in the interpolating track
Find new values at times t for the interpolatring tracks using linear interpolation
Find the interpolating z value, M1*v1 + M2*v2
Find the final interpolated value, v=Z1*v1 + Z2*v2
Reimplemented in Radius.
Reimplemented from JIT_Property.
|
inlinevirtualinherited |
Reimplemented from JIT_Property.
Estimate the lambda for a given star. The binding energy of an envelope is Ebind = Integrate^Mtot_Mcore dM - G M(r)/r + alpha_th*U, where U is the internal energy and alpha_th a fraction of internal energy used to unbound the envelope. For simplicity we can write Ebind_s = -G Mtot Menv / lambda R, where lambda is the factor for which Ebind_s=Ebind. Usually, the lambda is taken between two extrema: lambda_g obtained considering only the gravitational energy (alpha_th=0) and lambda_b obtained consider a fully efficiency of the internal energy in unbounding the envelope (alpha_th=1). The implementation depends on the Common envelope models and common envelope parameters
| star | Star for which we want to estimate the binding energy |
JIT properties
Reimplemented from Property.
Reimplemented from Property.
Reimplemented from Property.
|
private |
Pointer to Lambda Klencki class Estimate the bse-like parameter M0 (it is the mass at the end of the MS) We estimate it creating an auxilixiary star with the same Mzams and Z and estimate the mass at the tms. Since this value depends only on Mzams and Z, the results is cached in the member variable M0_cached.
| s | Pointer to the star |
|
private |
Get the value of the property expected at the end of the evolution (before becoming a remnant). It is based on the last values of the tables.
| s | Pointer to the star |
|
inlineinherited |
|
inlineinherited |
|
inlinevirtualinherited |
|
inlineoverridevirtual |
Reimplemented from JIT_Property.
|
inlineprotectedinherited |
|
inlineprotectedinherited |
|
inlinevirtualinherited |
Reset to 0
|
inlineoverridevirtualinherited |
Reimplemented from Property.
|
inlinevirtualinherited |
|
inlineprotectedvirtualinherited |
|
inlineoverrideprotectedvirtualinherited |
Reimplemented from Property.
|
inlineprotectedvirtualinherited |
Reimplemented in Radius.
|
inlineprotectedinherited |
Reimplemented from Property.
|
inlineprotectedinherited |
Reimplemented in TableProperty, OptionalTableProperty, Inertia, RHE, RCO, SurfaceAbundanceTable, and ConvectiveTable.
Reimplemented from JIT_Property.
|
inlineprotectedinherited |
Reimplemented in TableProperty.
|
inlinestaticinherited |
|
inlineoverridevirtualinherited |
Reimplemented from Derived_Property.
|
inlinevirtualinherited |
|
inlineoverridevirtual |
Reimplemented from Property.
Not needed to update JIT properties after binary evolution, they are estimated on request
Reimplemented from Property.
|
inlineoverrideinherited |
|
inlinevirtualinherited |
Reimplemented in dMcumul_RLO, and Radius.
|
inlinevirtualinherited |
|
static |
|
staticprotectedinherited |
Instruction for adding new property PROP 1- Add the size_t PROP::ID 2- Initialise the static (fake) instance PROP PROP::_prop. NB: take care of the order of initilisation. The properies will be evolved exactly in the same order in which they are initialised here Define: @size: total number of instances of Property and derived classes (both fake and real). @all: vector containing all the (pointers) to the Property. @PrintMap: map containing the pair (Property_name, Property_id) for output purpose. Note all and PrintMap are filled during the instantiation of the fake Processes (see below)
|
staticinherited |
|
protectedinherited |
|
privateinherited |
|
private |
Lambda Klencki
|
static |
|
protectedinherited |
|
private |
Used in some lambda estimate (e.g. Klencki) to check if it is needed to initialise stuff
|
privateinherited |
|
private |
|
private |
Cached values for BSE-like MOBSE-like lambdas
|
private |
|
staticinherited |
|
private |
|
protectedinherited |
|
protectedinherited |
|
protectedinherited |
|
inherited |
|
inherited |
|
protectedinherited |
|
protectedinherited |
|
protectedinherited |
|
protectedinherited |
|
protectedinherited |
|
private |
|
private |