Circularisation.h

Go to the documentation of this file.

//
// Created by iorio on 7/22/22.
//
 
#ifndef SEVN_CIRCULARISATION_H
#define SEVN_CIRCULARISATION_H
 
#include <Processes.h>
 
//Forward declaration
class Star;
class Binstar;
 
class Circularisation : public  Process {
public:
    Circularisation(_UNUSED IO *_io= nullptr, bool reg = true) {
        if (reg) {
            //First register to include this Property in static array
            Register(this, &ID, name());
        }
    }
    virtual ~Circularisation(){};
 
    static size_t ID;
    static Circularisation _circularisation;
    inline std::string name() override { return "Circularisation"; }
 
    Circularisation *Instance(_UNUSED IO *_io) override;
    virtual Circularisation *instance() {return nullptr;}
 
protected:
    //this a prototype for the future refactoring of the whole Process classes
    static std::map<std::string, Circularisation *> & GetStaticMap(){
        static std::map<std::string, Circularisation *> _locmap;
        return _locmap;
    }
    static std::vector<int> & GetUsed(){
        static std::vector<int> _used;
        return _used;
    }
    static void Register_specific(Circularisation *ptr) {
        GetStaticMap().insert(std::make_pair(ptr->name(), ptr));
        GetUsed().resize(GetStaticMap().size());
        GetUsed()[GetUsed().size()-1] = 0;
    }
 
 
};
 
 
 
 
class CircularisationDisabled : public Circularisation{
 
public:
 
    CircularisationDisabled(_UNUSED IO *_io= nullptr, bool reg = true) : Circularisation(nullptr, false) {
        if(reg) {
            //Second register to handle the different options
            Register_specific(this);
        }
    }
 
    inline std::string name() override { return "disabled"; }
    static CircularisationDisabled _circularisationdisabled;
    CircularisationDisabled* instance() override {
        return (new CircularisationDisabled(nullptr,false));
    }
    int evolve(_UNUSED Binstar *binstar) override;
};
 
class StandardCircularisation : public Circularisation{
 
public:
    StandardCircularisation(_UNUSED IO *_io= nullptr, bool _UNUSED = true) : Circularisation(nullptr, false) {}
 
     int evolve(_UNUSED Binstar *binstar) override;
 
 
    int special_evolve(_UNUSED Binstar *binstar) override;
 
protected:
 
    bool check_condition=false; 
    virtual int circularise(_UNUSED Binstar *binstar) = 0;
 
    virtual bool check_activation(Binstar *binstar) const;
 
 
    //Log message
    virtual std::string log_message_circ(Binstar *binstar, double a_new, double e_new) const;
 
};
 
class CircularisationPeriastron : public StandardCircularisation{
 
public:
 
    CircularisationPeriastron(_UNUSED IO *_io= nullptr, bool reg = true) : StandardCircularisation(nullptr, false) {
        if(reg) {
            //Second register to handle the different options
            Register_specific(this);
        }
    }
 
    inline std::string name() override { return "periastron"; }
    static CircularisationPeriastron _circularisationperiastron;
    CircularisationPeriastron* instance() override {
        return (new CircularisationPeriastron(nullptr,false));
    }
 
protected:
 
    int circularise(_UNUSED Binstar *binstar) override;
 
};
 
class CircularisationPeriastronFull : public CircularisationPeriastron{
 
public:
 
    CircularisationPeriastronFull(_UNUSED IO *_io= nullptr, bool reg = true) : CircularisationPeriastron(nullptr, false) {
        if(reg) {
            //Second register to handle the different options
            Register_specific(this);
        }
    }
 
    inline std::string name() override { return "periastron_full"; }
    static CircularisationPeriastronFull _circularisationperiastronfull;
    CircularisationPeriastronFull* instance() override {
        return (new CircularisationPeriastronFull(nullptr,false));
    }
 
protected:
 
     bool check_activation(Binstar *binstar) const override;
 
};
 
class CircularisationAngMom : public StandardCircularisation{
 
public:
 
    CircularisationAngMom(_UNUSED IO *_io= nullptr, bool reg = true) : StandardCircularisation(nullptr, false) {
        if(reg) {
            //Second register to handle the different options
            Register_specific(this);
        }
    }
 
    inline std::string name() override { return "angmom"; }
    static CircularisationAngMom _circularisationangmom;
    CircularisationAngMom* instance() override {
        return (new CircularisationAngMom(nullptr,false));
    }
 
protected:
 
    int circularise(_UNUSED Binstar *binstar) override;
 
};
 
class CircularisationSemimajor : public StandardCircularisation{
 
public:
 
    CircularisationSemimajor(_UNUSED IO *_io= nullptr, bool reg = true) : StandardCircularisation(nullptr, false) {
        if(reg) {
            //Second register to handle the different options
            Register_specific(this);
        }
    }
 
    inline std::string name() override { return "semimajor"; }
    static CircularisationSemimajor _circularisationsemimajor;
    CircularisationSemimajor* instance() override {
        return (new CircularisationSemimajor(nullptr,false));
    }
 
protected:
 
    int circularise(_UNUSED Binstar *binstar) override;
 
};
 
 
 
 
#endif //SEVN_CIRCULARISATION_H