supernova.h

Go to the documentation of this file.

/*
Created by spera on 30/12/18.
Module for SN models, it includes:
 - Class supernova: Base class for SN models
 - Class PisnON:  auxiliary  class-option used to enable pair instability at compile time
 - Class PisnOFF: auxiliary class-option used to disable pair instability at compile time
 - Class NeutrinoMassLossOFF: auxiliary class-option used to disable neutrino mass loss at compile time
 - Class NSfromGau: auxiliary class-option used to force to draw Neutron Star masses from a Gaussian
*/
 
#ifndef SEVN_SUPERNOVA_H
#define SEVN_SUPERNOVA_H
 
#include <string>
#include <map>
#include <vector>
#include <sevnlog.h>
#include <lookup_and_phases.h>
#include <kicks.h>
#include <random>
#include <neutrinomassloss.h>
 
class Star;
class PairInstability;
using sevnstd::SevnLogging;
 
#define _UNUSED __attribute__ ((unused))
 
 
class supernova {
 
/***** For Developers that want to add new supernova models: ******/
public:
    virtual inline std::string name() const { return "GenericSupernova"; }
    virtual supernova *instance(_UNUSED Star *s) = 0; //Pure virtual
 
    virtual void explosion(Star *s) = 0;
 
 
 
protected:
 
    virtual Lookup::Remnants  set_remnant_type_after_explosion(Star *s, double mremnant, Lookup::SNExplosionType sntype);
 
    virtual void CCexplosion(Star *s);
 
    virtual void ECSN(Star *s);
 
    virtual void WDformation(Star *s);
 
 
 
 
 
    /*********************************************************************************************************/
    /***** STOP: DO NOT CHANGE THE REST OF THE CODE IF YOU ARE NOT FULLY AWARE OF WHAT  YOU ARE DOING ******/
    /*********************************************************************************************************/
public:
    //TODO Since Star is passed to the constructor, it can be stored as a pointer and the Star* s can be removed
    //in the other function calls
    supernova(Star *s = nullptr);
 
    virtual ~supernova();
 
    static supernova *Instance(std::string const &name, Star *s);
 
 
    void main(Star *s);
 
    void initialise_remnant(Star *s, double Mass_remnant, Lookup::Remnants Remnant_type);
 
 
    inline double get_fallback_frac() const { return fallback_frac; }
 
    inline double get_pisncorrection() const { return pisn_correction; }
 
    inline double get_M_neutrinos() const { return M_neutrinos; }
 
    inline double get_Mremnant() const { return Mremnant; }
 
    /*** Return the Mass of the remnant before the pisn and neutrino mass loss correction ***/
    inline double get_Mremnant_preCorrection() const {
        return Mremnant_preCorrection<0 ? Mremnant : Mremnant_preCorrection;
    }
 
    inline double get_AverageRemnant() const { return Average_remnant; }
    inline double get_AverageEjected() const { return Average_ejected; }
 
    inline double get_Mejected() const { return Mejected; }
    inline double get_remnant_type() const { return remnant_type; }
 
 
    virtual void explosion_SNI(Star *s);
 
    virtual void explosion_SNI(Star *s, Binstar *b);
 
    double  get_preSN_Mass(size_t massid) const;
 
 
protected:
    double fallback_frac, M_neutrinos;
    double pisn_correction;
    double Mremnant, Mejected, Mremnant_preCorrection;
    double Average_ejected, Average_remnant;
    Lookup::Remnants remnant_type;
    Lookup::SNExplosionType sn_type=Lookup::SNExplosionType::Unknown; //initialised to Unknown
 
    void Register(supernova *ptr) {
        //Register only if the name is not already in the map,
        //this is necessary to avoid multiple registration of the same model when the constructor is called from
        //inherited classes
        if (GetStaticMap().find(ptr->name())==GetStaticMap().end()){
            GetStaticMap().insert(std::make_pair(ptr->name(), ptr));
            GetUsed().resize(GetStaticMap().size());
            GetUsed()[GetUsed().size() - 1] = 0;
        }
    }
 
 
    double Mass_corrections_after_explosion(const double mass, Star *s);
 
    virtual double pisn(const double mass, Star *s) = 0;
 
    const PairInstability* get_pairinstability() const {return  pairinstability;}
 
    virtual double neutrino_mass_loss(const double mass, Star *s) const;
 
    void set_Average_for_Unified(Star* s, double default_Average_Mremnant, double default_Average_Mejected);
 
 
    SevnLogging svlog;
 
    virtual int set_preSN_Masses(Star *s) = 0;
 
    int _set_preSN_Masses(Star *s, bool allow_pisn);
 
 
 
private:
    Kicks *kick;
    PairInstability *pairinstability;
    NeutrinoMassLoss *neutrinomassloss;
    //std::unique_ptr<Kicks> *kick;
 
    //preSN Mass container
    utilities::MassContainer* Mass_preSN=nullptr;
 
    static std::map<std::string, supernova *> &GetStaticMap() {
        static std::map<std::string, supernova *> _locmap;
        return _locmap;
    }
 
    static std::vector<int> &GetUsed() {
        static std::vector<int> _used;
        return _used;
    }
 
    void remnant_properties(Star *s);
 
    void set_staremnant(Star *s);
 
 
 
};
 
 
class PisnON : virtual public supernova{
public:
    PisnON(){}
protected:
    int set_preSN_Masses(Star *s) override;
 
    double pisn(const double mass, Star *s) override;
 
};
 
class PisnOFF : virtual public supernova{
public:
    PisnOFF(){}
protected:
    int set_preSN_Masses(Star *s) override;
 
    double pisn(const double mass, Star *s) override;
 
};
 
class NeutrinoMassLossOFF : virtual public supernova{
public:
    NeutrinoMassLossOFF(){}
    NeutrinoMassLossOFF(_UNUSED Star *s){}
protected:
    double neutrino_mass_loss(const double mass, _UNUSED Star *s)  const override {return  mass;}
};
 
class NSfromGau : virtual public supernova {
public:
    NSfromGau(){}
    void ECSN(Star *s) override;
    double get_NS_mass(Star *s);
 
protected:
    std::normal_distribution<double> normal_dist{0.,1.};
    inline double generate_random_gau(double mean, double std){
      return normal_dist(utilities::mtrand)*std + mean;
    }
 
     void CCexplosion(Star *s) override;
 
};
 
 
 
 
 
 
#endif //SEVN_SUPERNOVA_H