SEVN
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Static Private Member Functions | List of all members
PIIorio22Limited Class Reference

#include <piiorio22.h>

Inheritance diagram for PIIorio22Limited:
PIIorio22 PairInstability

Public Member Functions

 PIIorio22Limited (bool reg=true)
 
std::string name () const override
 
PIIorio22Limited * instance () override
 
utilities::MassContainer apply_beforeSN (_UNUSED Star *s) const override
 
PISNreturn apply_afterSN (_UNUSED Star *s, _UNUSED double mremnant) const override
 

Static Public Member Functions

static PairInstability * Instance (std::string const &name)
 Base class. More...
 

Static Public Attributes

static PIIorio22Limited _piiorio22limited
 
static PIIorio22 _piiorio22
 

Protected Member Functions

double ppisn_mass_limitation (_UNUSED double Mremnant, _UNUSED Star *s) const override
 

Static Protected Member Functions

static void Register (PairInstability *ptr)
 

Protected Attributes

SevnLogging svlog
 

Static Private Member Functions

static std::map< std::string, PairInstability * > & GetStaticMap ()
 Option handling. More...
 
static std::vector< int > & GetUsed ()
 TODO we are never using this method, we should remove it. More...
 

Detailed Description

iorio22_limited option

Same as iorio22 but with an upper limit on the PPISN BH mass following Eq. 2 in Farmer+19 see:

Modification with respect to the standard

  • apply_beforeSN: modify the preSN mass
    • MCO<38 Msun or MHE>135 Msun -> not modifications
    • MCO>=38 Msun and (MHE<=135 Msun)-> Mass=MHE=MCO
  • apply_afterSN:
    • MCO<38 Msun or MHE>135 Msun, no mass correction ->Core Collapse
    • 38 Msun<=MCO<=60 Msun, limit BH mass using the *MBH_max from Equation 2 in Farmer+19 -> PPISN *MBH_max=35.1 -3.9 log10(Z) -0.31 log10(Z)*log10(Z), where Z is the metallicity
    • MCO>60 Msun and (MHE<135 Msun), set Mremnant to 0 -> PISN

Constructor & Destructor Documentation

◆ PIIorio22Limited()

PIIorio22Limited::PIIorio22Limited ( bool  reg = true)
explicit

Member Function Documentation

◆ apply_afterSN()

PISNreturn PIIorio22::apply_afterSN ( _UNUSED Star *  s,
_UNUSED double  mremnant 
) const
overridevirtualinherited

Main function to call to apply the pair instability after the SN explosion This function has to be called after the remnant mass has been defined. It apply a correction to the remnant mass (if needed) and set the SNtype The method of the base class just set Mremnant_after_pi=mremnant and SNType=CoreCollapse NOTICE: the default method does nothing, just initialise the PISNreturn with:

  • Mremnant_after_pi=mremnant
  • SNType=Lookup::SNExplosionType::CoreCollapse
    Parameters
    sPointer to the exploding star to which we want to apply the correction
    mremnantMass of the remnant before the pair instability correction
    Returns
    an Instance of the struct PISNeturn with only two members:
  • Mremnant_after_pi, Mass of the remnant after the application of pi
  • SNType: SN explosion type an object of the enum Lookup::SNExplosionType (ElectronCapture, CoreCollapse, PPISN,PISN)

Reimplemented from PairInstability.

◆ apply_beforeSN()

utilities::MassContainer PIIorio22::apply_beforeSN ( _UNUSED Star *  s) const
overridevirtualinherited

Methods that can be customized in new models: NOTICE these are the two methods that actually estimate the pisn corrections. By default they do nothing (indeed they are not changed in the disabled model) You may want to change one or both of them Main function to call to apply the pulsation pair instability before the SN explosion The function return a structure containing the modified preSN stellar mass(es) (total mass, MHE, MCO) due to the pulsation pair instability. This function should be called before estimating the final mass in the explosion method in the Supernova classes The method of the base class just copy the Mass,MHE and MCO NOTICE: the default method does nothing, just initialise the utilities::MassContainer with the current stellar mass properties

Parameters
sPointer to the exploding star
Returns
an Instance of the struct PPISNMass with only three members:
  • Mass_after_ppi, Mass of the star before the explosion due to the pulsation pair instability
  • MHE_after_ppi: Mass of the HE core of the star before the explosion due to the pulsation pair instability
  • MCO_after_ppi: Mass of the CO core of the star before the explosion due to the pulsation pair instability

Reimplemented from PairInstability.

◆ GetStaticMap()

static std::map< std::string, PairInstability * > & PairInstability::GetStaticMap ( )
inlinestaticprivateinherited

Option handling.

◆ GetUsed()

static std::vector< int > & PairInstability::GetUsed ( )
inlinestaticprivateinherited

TODO we are never using this method, we should remove it.

◆ instance()

PIIorio22Limited * PIIorio22Limited::instance ( )
inlineoverridevirtual

Create an instance of the class allocated on the heap

Returns
a pointer to a real instance of the class that is allocated on the heap

Reimplemented from PIIorio22.

◆ Instance()

PairInstability * PairInstability::Instance ( std::string const &  name)
staticinherited

Base class.

Generic method to call an instance based on name

Parameters
namename of the option
Returns
a pointer to a real instance of the class that is allocated on the heap

◆ name()

std::string PIIorio22Limited::name ( ) const
inlineoverridevirtual

Remember that each new proper PairInstability model has to have a public static class instance to define in static_main.h e.g. static MyModel _mymodel; (in the class) and MyModel MyModel::_mymodel; in static_main.h Methods that must be customized in new models Name of the PairInstability model, this will be use at runtime to select the given model

Reimplemented from PIIorio22.

◆ ppisn_mass_limitation()

double PIIorio22Limited::ppisn_mass_limitation ( _UNUSED double  Mremnant,
_UNUSED Star *  s 
) const
overrideprotectedvirtual

Apply a mass limit to the BH mass after ppisn Limit the BH mass to the MBH_max obtained with Eq. 2 in Farmer+19: MBH_max=35.1 -3.9 log10(Z) -0.31 log10(Z)*log10(Z), where Z is the metallicity

Parameters
MremnantRemnant mass before the application of the mass limit
sPointer to the exploding star
Returns
New value of the remnant mass after the application of the limits

Reimplemented from PIIorio22.

◆ Register()

void PairInstability::Register ( PairInstability *  ptr)
staticprotectedinherited

Register function, to be called inside the option constructor to register the given option

Member Data Documentation

◆ _piiorio22

PIIorio22 PIIorio22::_piiorio22
staticinherited

◆ _piiorio22limited

PIIorio22Limited PIIorio22Limited::_piiorio22limited
static

◆ svlog

SevnLogging PairInstability::svlog
protectedinherited
The documentation for this class was generated from the following files: