EccentricityExpansionCoefficients.h

Go to the documentation of this file.

#ifndef __ECCENTRICITY_EXPANSION_COEFFICIENTS_H
#define __ECCENTRICITY_EXPANSION_COEFFICIENTS_H

#include "../Core/SharedLibraryExportMacros.h"
#include "../Core/Error.h"
#include "../Core/Common.h"
#include <vector>
#include <fstream>
#include <iomanip>
#include <cmath>
#include <iostream>
#include <sstream>
#include <cassert>
#include <algorithm>
#include <sqlite3.h>
//#include <boost/math/special_functions/chebyshev.hpp>

namespace Evolve {

    class LIB_PUBLIC EccentricityExpansionCoefficients {
    private:
        bool __useable;

        bool __allow_precision_fail;

        std::vector< std::vector<double> >
            __pms_interp_data;



        int __max_s;

        double __expansion_precision;

        bool __load_all;

        std::vector<int> __db_pms_id;

        std::vector<double> __min_e;

        std::vector<int> __num_steps;

        std::vector<double> __max_e;


        std::vector<double> __interp_precision;

        std::string __file_name;

        std::vector<double> __max_ignore_eccentricity;

        std::vector<double> load_coefficient(sqlite3* db,int m,int s);

        void set_max_s(sqlite3* db);

        void load_metadata(sqlite3* db);

        void load_max_ignore_eccentricity(sqlite3* db, double precision);

        double load_specific_e(int m,int s,int e_step) const;
        void get_interp_data(sqlite3* db);

        double get_specific_e(
            int m,

            int s,

            int e_step
        ) const;

        std::vector<double> find_pms_boundary_values(int m,int s,double e) const;
        double return_known_e(int m, int s, double e) const;
        bool check_known_e(int m,int s,double e) const;
        inline int e_to_nearest_step(int m,int s,double e,bool flr) const;
        inline double step_to_e(int m,int s,int step) const;
        int current_largest_s(int m);
        inline int local_index(int m, int s) const;
        //void change_frequency_order(double new_e); // Has not been implemented yet but is new and is intended to be

        std::vector<double>* which_list(int m);
        int* which_order(int m);

    public:
        EccentricityExpansionCoefficients() : __useable(false) {}

        void prepare(
                const std::string &tabulated_pms_fname,

                double precision,

                bool pre_load,

                bool disable_precision_fail=false
        );

        inline double get_expansion_precision() const
        {return __expansion_precision;}

        double interp_precision(int m, int s) const;

        //\f$s'>s\f$ can be ignored from the expansion without violating the
        int required_expansion_order(double e, int m) const;

        int max_expansion_order() const
        {return __max_s;}

        std::pair<double,double> get_expansion_range(int m, int max_s) const;

        double operator()(
                int m,

                int s,

                double e,

                bool deriv
        ) const;

    }; //End EccentricityExpansionCoefficients class.

} //End Evolve namespace.

#endif