MTstability.h

Go to the documentation of this file.

//
// Created by Giuliano Iorio on 17/11/2021.
//
// Classes to handle the MT stability
//
//
 
#ifndef SEVN_MTSTABILITY_H
#define SEVN_MTSTABILITY_H
 
#include <string>
#include <map>
#include <utility>
#include <vector>
 
#include <sevnlog.h>
 
#define set_prop(star,prop,old) old ? star->getp_0(prop::ID) :  star->getp(prop::ID)
 
 
class Star;
class Binstar;
using sevnstd::SevnLogging;
 
class MTstability{
 
public:
    virtual inline std::string name() = 0;
    static MTstability *Instance(std::string const &name);
    virtual MTstability *instance(){ svlog.critical("This is supposed to be pure virtual, do you have an uninitialized module?", __FILE__, __LINE__); return nullptr; }
 
    virtual bool mt_unstable(Star *donor, Star *accretor, _UNUSED Binstar *binary) const = 0;
 
    virtual ~MTstability(){
    }
 
    virtual double get_tshold(_UNUSED Star *donor, _UNUSED Star *accretor, _UNUSED Binstar *binary) const = 0;
 
    virtual double get(_UNUSED Star *donor, _UNUSED Star *accretor, _UNUSED Binstar *binary) const = 0;
 
protected:
 
    void Register(MTstability *ptr, const std::string &_name) {
        GetStaticMap().insert(std::make_pair(_name, ptr));
        GetUsed().resize(GetStaticMap().size());
        GetUsed()[GetUsed().size()-1] = 0;
    }
 
    SevnLogging svlog;
 
private:
 
    static std::map<std::string, MTstability *> & GetStaticMap(){
        static std::map<std::string, MTstability *> _locmap;
        return _locmap;
    }
 
    static std::vector<int> & GetUsed(){
        static std::vector<int> _used;
        return _used;
    }
 
};
 
 
class MT_Stable : public  MTstability{
 
public:
    MT_Stable(bool  reg = true){
        if (reg){
            Register(this, name());
        }
    }
 
    inline std::string name() override { return "stable"; }
 
     bool mt_unstable(_UNUSED Star *donor, _UNUSED Star *accretor, _UNUSED Binstar *binary)  const override {return false;}
 
    double get_tshold(_UNUSED Star *donor, _UNUSED Star *accretor, _UNUSED Binstar *binary) const override {return 1E30;}
 
    double get(_UNUSED Star *donor, _UNUSED Star *accretor, _UNUSED Binstar *binary) const override {return 0.;}
 
    static MT_Stable _mt_stable;
 
    MT_Stable* instance() override {
        return (new MT_Stable(false));
    }
 
};
 
class MT_UnStable : public  MTstability{
 
public:
    MT_UnStable(bool  reg = true){
        if (reg){
            Register(this, name());
        }
    }
 
    inline std::string name() override { return "unstable"; }
 
    bool mt_unstable(_UNUSED Star *donor, _UNUSED Star *accretor, _UNUSED Binstar *binary)  const override {return true;}
 
    double get_tshold(_UNUSED Star *donor, _UNUSED Star *accretor, _UNUSED Binstar *binary) const override {return -1E30;}
 
    double get(_UNUSED Star *donor, _UNUSED Star *accretor, _UNUSED Binstar *binary) const override {return 0.;}
 
    static MT_UnStable _mt_unstable;
 
    MT_UnStable* instance() override {
        return (new MT_UnStable(false));
    }
 
};
 
 
class MT_Qcrit : public MTstability{
 
public:
 
    bool mt_unstable(Star *donor, Star *accretor, _UNUSED Binstar *binary)  const override;
 
    double get_tshold(Star *donor, Star *accretor, _UNUSED Binstar *binary) const override {return qcrit(donor,accretor);}
     double get(Star *donor, Star *accretor, _UNUSED Binstar *binary) const override {return q(donor,accretor);}
 
protected:
 
    virtual double q(Star *donor, Star *accretor) const;
 
    virtual double qcrit(Star *donor, Star *accretor) const = 0;
 
};
 
class Qcrit_Hurley : public MT_Qcrit{
 
public:
 
    Qcrit_Hurley(bool  reg = true){
        if (reg){
            Register(this, name());
        }
    }
 
    inline std::string name() override { return "qcrit_hurley"; }
 
    static Qcrit_Hurley _qcrit_hurley;
 
    Qcrit_Hurley* instance() override {
        return (new Qcrit_Hurley(false));
    }
 
protected:
 
    double qcrit(Star *donor, Star *accretor) const override;
 
    virtual double qcrit_giant(Star *donor, _UNUSED Star *accretor) const;
 
};
 
class Qcrit_Hurley_Webbink : public Qcrit_Hurley{
 
public:
 
    Qcrit_Hurley_Webbink(bool  reg = true){
        if (reg){
            Register(this, name());
        }
    }
 
    inline std::string name() override { return "qcrit_hurley_webbink"; }
 
    static Qcrit_Hurley_Webbink _qcrit_hurley_webbink;
 
    Qcrit_Hurley_Webbink* instance()  override {
        return (new Qcrit_Hurley_Webbink(false));
    }
 
protected:
 
    double qcrit_giant(Star *donor, _UNUSED Star *accretor) const override;
 
};
 
class Qcrit_Hurley_Webbink_Shao : public Qcrit_Hurley_Webbink {
 
public:
 
    Qcrit_Hurley_Webbink_Shao(bool  reg = true){
        if (reg){
            Register(this, name());
        }
    }
 
    inline std::string name() override { return "qcrit_hurley_webbink_shao"; }
 
    static Qcrit_Hurley_Webbink_Shao _qcrit_hurley_webbink_shao;
 
    Qcrit_Hurley_Webbink_Shao* instance() override {
        return (new Qcrit_Hurley_Webbink_Shao(false));
    }
 
protected:
 
    double qcrit(Star *donor, Star *accretor) const override;
 
};
 
class Qcrit_COSMIC_Neijssel : public Qcrit_Hurley_Webbink{
 
public:
 
    Qcrit_COSMIC_Neijssel(bool  reg = true){
        if (reg){
            Register(this, name());
        }
    }
 
    inline std::string name() override { return "qcrit_cosmic_neijssel"; }
 
    static Qcrit_COSMIC_Neijssel _qcrit_cosmic_neijssel;
 
    Qcrit_COSMIC_Neijssel* instance() override {
        return (new Qcrit_COSMIC_Neijssel(false));
    }
 
protected:
    double qcrit(Star *donor, Star *accretor) const override;
 
};
 
class Qcrit_COSMIC_Claeys: public Qcrit_Hurley_Webbink{
 
public:
 
    Qcrit_COSMIC_Claeys(bool  reg = true){
        if (reg){
            Register(this, name());
        }
    }
 
    inline std::string name() override { return "qcrit_cosmic_claeys"; }
 
    static Qcrit_COSMIC_Claeys _qcrit_cosmic_claeys;
 
    Qcrit_COSMIC_Claeys* instance() override {
        return (new Qcrit_COSMIC_Claeys(false));
    }
 
protected:
    double qcrit(Star *donor, Star *accretor) const override;
 
 
};
 
class Qcrit_StarTrack : public MT_Qcrit{
 
public:
 
    Qcrit_StarTrack(bool  reg = true){
        if (reg){
            Register(this, name());
        }
    }
 
    inline std::string name() override { return "qcrit_startrack"; }
 
    static Qcrit_StarTrack _qcrit_startrack;
 
    Qcrit_StarTrack* instance() override {
        return (new Qcrit_StarTrack(false));
    }
 
protected:
 
    double qcrit(Star *donor, _UNUSED  Star *accretor) const override;
 
};
 
class Qcrit_Radiative_Stable : public Qcrit_Hurley_Webbink{
public:
 
    Qcrit_Radiative_Stable(bool  reg = true){
        if (reg){
            Register(this, name());
        }
    }
 
    inline std::string name() override { return "qcrit_radiative_stable"; }
 
    static Qcrit_Radiative_Stable _qcrit_radiative_stable;
 
    Qcrit_Radiative_Stable* instance() override {
        return (new Qcrit_Radiative_Stable(false));
    }
 
protected:
    double qcrit(Star *donor, Star *accretor) const override;
 
};
 
class Qcrit_HRadiative_Stable : public Qcrit_Hurley_Webbink{
public:
 
    Qcrit_HRadiative_Stable(bool  reg = true){
        if (reg){
            Register(this, name());
        }
    }
 
    inline std::string name() override { return "qcrit_Hradiative_stable"; }
 
    static Qcrit_HRadiative_Stable _qcrit_hradiative_stable;
 
    Qcrit_HRadiative_Stable* instance() override {
        return (new Qcrit_HRadiative_Stable(false));
    }
 
protected:
    double qcrit(Star *donor, Star *accretor) const override;
 
};
 
class MT_Zeta : public MTstability{
 
public:
 
    bool mt_unstable(Star *donor, Star *accretor, _UNUSED Binstar *binary)  const override;
 
    virtual double get_tshold(Star *donor, Star *accretor, _UNUSED Binstar *binary) const {return qcrit(donor,accretor);}
    virtual double get(Star *donor, Star *accretor, _UNUSED Binstar *binary) const {return q(donor,accretor);}
 
protected:
 
    virtual double q(Star *donor, Star *accretor) const;
 
    virtual double qcrit(Star *donor, Star *accretor) const = 0;
 
};
 
 
 
#endif //SEVN_MTSTABILITY_H