testOrbitSolver.h

Go to the documentation of this file.

#ifndef __TEST_ORBIT_SOLVER_H
#define __TEST_ORBIT_SOLVER_H

#include "TransformedSolution.h"
#include "RealEvolutionQuantity.h"
#include "ExpectedEvolutionMode.h"
#include "Oblique10LinearQuantity.h"
#include "Oblique20LinearQuantity.h"
#include "InverseLinearLconvEvolution.h"
#include "ConservedLEObliquityEvolution.h"
#include "../../Evolve/OrbitSolver.h"
#include "../../Star/EvolvingStar.h"
#include "../../Planet/Planet.h"
#include "../../Evolve/DiskBinarySystem.h"
#include "../../Core/AstronomicalConstants.h"
#include "../shared/PolynomialEvolution.h"
#include "../shared/Common.h"
#include "../shared/MakeStar.h"
#include <iostream>
#include <vector>

namespace Evolve {

    class test_OrbitSolver : public Test::Suite {
    private:
        Evolve::OrbitSolver *__solver;

        Evolve::DiskBinarySystem *__system;

        Star::InterpolatedEvolutionStar *__star;

        Planet::Planet *__primary_planet;

        std::vector< const Core::OneArgumentDiffFunction* > __temp_functions;

        //component.
        void set_single_component_dissipation(
            double min_frequency,

            double max_frequency,

            double decay_scale,

            double phase_lag = 1.0e-5
        );

        void make_single_component_star(
            const StellarEvolution::Interpolator &evolution,

            double wind_strength,

            double wind_sat_freq,

            double coupling_timescale,

            double min_frequency,

            double max_frequency,

            double decay_scale,

            double phase_lag = 1.0e-5
        );

        void evolve(
            double wdisk,
            double tdisk,
            double initial_a,
            const double *initial_Lstar,
            double initial_incl = 0.0,
            double secondary_mass = 1.0,
            double tsecondary = Core::NaN,
            double max_age = MAX_AGE,
            double secondary_radius = 1.0,
            double precision = 1e-8,
            double max_step_factor = 1e-3,
            const std::list<double> required_ages = std::list<double>()
        );

        std::vector< const std::list<double> *> get_evolution() const;

        void test_solution(
            const std::vector< const std::list<double> * > &
                tabulated_real_quantities,
            std::vector<const Core::OneArgumentDiffFunction *>
                expected_real_quantities,
            const ExpectedEvolutionMode<Core::EvolModeType> &
                expected_evol_mode,
            const ExpectedEvolutionMode<bool> &expected_wind_mode,
            double min_age,
            double max_age,
            bool debug_mode = false
        );

        void test_no_planet_scenario(
            const StellarEvolution::Interpolator &stellar_evol,
            double *initial_Lstar,
            double windK,
            double wind_sat_freq,
            double core_env_coupling_time,
            std::vector<const Core::OneArgumentDiffFunction *>
                &expected_evolution,
            const ExpectedEvolutionMode<bool> &expected_wind_mode,
            double max_age = MAX_AGE,
            bool debug_mode = false
        );

        std::vector<const Core::OneArgumentDiffFunction *>
            calculate_expected_unlocked_evolution(
                double phase_lag,

                double secondary_mass,

                bool decaying=true
            );

        std::vector<const Core::OneArgumentDiffFunction *>
            calculate_expected_disklocked_to_fast_to_locked(
                double lgQ,

                double tdisk,

                double async,

                double tsync,

                double tend,

                bool include_disk_lock=true
            );

        std::vector<const Core::OneArgumentDiffFunction *>
            calculate_expected_polar_1_0(
                double tdisk,

                double wstar,

                double worb
            );

        std::vector<const Core::OneArgumentDiffFunction *>
            calculate_expected_polar_2_0(
                double tdisk,

                double wstar,

                double worb,

                double phase_lag,

                double &lconv_decay_rate,

                //envolve).
                double &semimajor
            );

        std::vector<const Core::OneArgumentDiffFunction *>
            calculate_expected_oblique_m_0(
                unsigned m,

                double tdisk,

                double worb,

                double initial_inc,

                double initial_wstar,

                double phase_lag,

                double &min_wstar
            );

    protected:
        void setup();

        void tear_down();
    public:
        test_OrbitSolver();

        void test_disk_locked_no_stellar_evolution();

        void test_disk_locked_with_stellar_evolution();

        void test_no_planet_evolution();

        //
        void test_unlocked_evolution();

        void test_locked_evolution();

        void test_disklocked_to_locked_to_noplanet();

        void test_disklocked_to_fast_to_noplanet();

        void test_disklocked_to_fast_to_locked();

        void test_disklocked_to_locked_to_fast();

        void test_polar_1_0_evolution();

        void test_polar_2_0_evolution();

        void test_oblique_1_0_evolution();

        void test_oblique_2_0_evolution();
    };//End test_OrbitSolver class.

}//End Evolve namespace.


#endif