BrokenPowerlawPhaseLagZone.h

Go to the documentation of this file.

#ifndef __BROKEN_POWERLAW_PHASE_LAG_ZONE
#define __BROKEN_POWERLAW_PHASE_LAG_ZONE

#include "../Core/SharedLibraryExportMacros.h"
#include "DissipatingZone.h"
#include "DissipatingBody.h"
#include "BinarySystem.h"
#include "LagForcingFrequencyBreakCondition.h"
#include "LagSpinBreakCondition.h"


namespace Evolve {

    class LIB_PUBLIC BrokenPowerlawPhaseLagZone : virtual public DissipatingZone {
        friend class LagForcingFrequencyBreakCondition;
        friend class LagSpinBreakCondition;
    private:
        bool
            __dissipative,

            __can_lock;

        std::vector<double>
            __tidal_frequency_breaks,

            __spin_frequency_breaks,

            __tidal_frequency_powers,

            __spin_frequency_powers,

            __break_phase_lags;

        double
            __inertial_mode_enhancement,

            __inertial_mode_sharpness;

        std::vector<double>::size_type __spin_index;

        std::vector< std::vector<double>::size_type > __tidal_indices;

        inline std::vector< std::vector<double>::size_type >::size_type
            tidal_term_index(
                int orbital_frequency_multiplier,

                int spin_frequency_multiplier
            ) const
            {
                return (
                    2
                    +
                    (orbital_frequency_multiplier > 0 ? 1 : -1)
                    *
                    (
                        spin_frequency_multiplier
                        +
                        5 * orbital_frequency_multiplier
                    )
                );
            }

        double get_orbital_frequency(const BinarySystem &system) const;

        double get_inertial_mode_factor(
            //inertial mode enhancement is required.
            double abs_forcing_frequency,

            int orbital_frequency_multiplier,

            int spin_frequency_multiplier,

            //Dissipation::SPIN_FREQUENCY or Dissipation::ORBITAL_FREQUENCY,
            //return the derivative of the log of the enhancement factor w.r.t.
            Dissipation::QuantityEntry entry=Dissipation::NO_DERIV
        ) const;

        void reset();

        void set_spin_index();

        std::vector<double>::size_type get_tidal_index(
            double abs_forcing_frequency
        ) const;

        void add_tidal_frequency_conditions(
            BinarySystem &system,

            bool primary,

            unsigned zone_index,

            CombinedStoppingCondition &result
        );

        void print_configuration(std::ostream &out_stream = std::clog);

    public:
        BrokenPowerlawPhaseLagZone()
            : __dissipative(false), __can_lock(false) {}

        void setup(
            const std::vector<double> &tidal_frequency_breaks,

            const std::vector<double> &spin_frequency_breaks,

            const std::vector<double> &tidal_frequency_powers,

            const std::vector<double> &spin_frequency_powers,

            double reference_phase_lag,

            double inertial_mode_enhancement = 1.0,

            double inertial_mode_sharpness = 10.0
        );

        virtual void configure(
            bool initialize,
            double age,
            double orbital_frequency,
            double eccentricity,
            double orbital_angmom,
            double spin,
            double inclination,
            double periapsis,
            bool spin_is_frequency
        );

        virtual double modified_phase_lag(
            int orbital_frequency_multiplier,

            int spin_frequency_multiplier,

            double forcing_frequency,

            Dissipation::QuantityEntry entry,

            double &above_lock_value
        ) const;

        virtual double love_coefficient(
            int,

            int,

            Dissipation::QuantityEntry
        ) const
        {return 0;}

        virtual CombinedStoppingCondition *stopping_conditions(
            BinarySystem &system,

            bool primary,

            unsigned zone_index
        );

        virtual void change_e_order(
            unsigned new_e_order,

            BinarySystem &system,

            bool primary,

            unsigned zone_index
        );

        virtual bool dissipative() const
        {return __dissipative;}

        virtual bool can_lock() const
        {return __can_lock;}

        ~BrokenPowerlawPhaseLagZone() {
#ifndef NDEBUG
            std::cerr << "Destroying powerlaw lag zone:"
                      << "Tidal breaks:";
            for(
                std::vector<double>::const_iterator
                    br_i = __tidal_frequency_breaks.begin();
                br_i != __tidal_frequency_breaks.end();
                ++br_i
            )
                std::cerr << " " << *br_i;
            std::cerr << "Spin breaks: ";
            for(
                std::vector<double>::const_iterator
                    br_i = __spin_frequency_breaks.begin();
                br_i != __spin_frequency_breaks.end();
                ++br_i
            )
                std::cerr << " " << *br_i;
            std::cerr << std::endl;
#endif
            reset();
        }

    }; //End BrokenPowerlawPhaseLagZone class.

} //End BinarySystem namespace.

#endif