Program Listing for File BrokenPowerlawPhaseLagZone.h

↰ Return to documentation for file (/home/kpenev/projects/git/poet/poet_src/Evolve/BrokenPowerlawPhaseLagZone.h)

#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;

        std::vector<double>
            __tidal_frequency_breaks,

            __spin_frequency_breaks,

            __tidal_frequency_powers,

            __spin_frequency_powers,

            __break_phase_lags;

        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;

        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) {}

        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
        );

        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;}

        ~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