poet.h

Go to the documentation of this file.

#ifndef __POET_H
#define __POET_H

#include "Core/Common.h"
#include "Core/AstronomicalConstants.h"
#include "StellarEvoltion/MESAIO.h"
#include "StellarEvolution/CustomStellarEvolution.h"
#include "BinarySystem/OrbitSolver.h"
#include "BinarySystem/EvolvingStar.h"
#include "BinarySystem/LockedPlanet.h"
#include "BinarySystem/DiskPlanetSystem.h"
#include "BinarySystem/ConstSolutionIterator.h"
#include "IO/IOColumns.h"
#include <argtable2.h>
#include <iostream>
#include <fstream>
#include <sstream>

std::vector<std::string>
    TRACK_COLUMN_NAMES(CustomStellarEvolution::NUM_TRACK_QUANTITIES);

std::string data_directory()
{
    std::string datadir=DATADIR;
    if(datadir[datadir.size()-1]!='/') datadir+='/';
    return datadir;
}

class CommandLineOptions {
private:

    std::vector<std::string> __input_column_names,

                 __output_column_descr,
                 
                 __track_column_descr,
                 
                 __track_column_units;

    std::vector<double> __defaults;

    std::vector<double> __default_track_smoothing;

    std::vector<int> __default_track_nodes;

    static const std::string __default_outfname,

        __default_serialized_evol,
        
        __default_output_columns,
        
        __default_track_columns,
        
        __default_eccentricity_expansion;

    std::vector<arg_dbl*> __direct_value_options;

    std::vector<arg_dbl*> __custom_track_smoothing;

    std::vector<arg_int*> __custom_track_nodes;

    arg_str *__input_file_columns,

            *__output_file_columns,
            
            *__required_ages_option,
            
            *__custom_stellar_evolution_format;

    arg_lit *__start_locked;

    arg_lit *__use_YREC;

    arg_file *__input_fname,

             *__output_fname,

             *__serialized_stellar_evolution,
             
             *__custom_stellar_evolution,
             
             *__eccentricity_expansion;

    void *__argtable[InCol::NUM_INPUT_QUANTITIES
                     +
                     2 * CustomStellarEvolution::AGE
                     +
                     10];

    std::vector<InCol::InputColumns> __input_file_format;

    std::vector<OutCol::OutputColumns> __output_file_format;

    std::vector<CustomStellarEvolution::Columns> __track_format;

    std::ifstream __input_stream;

    std::list<char*> __option_help_copies;

    std::list<double> __required_ages;

    bool __parsed_ok,

         __opened_stream,
         
         __need_orbit;

    char *cstr_copy(const std::ostringstream &stream)
    {return cstr_copy(stream.str());}

    char *cstr_copy(const std::string &str);

    void define_options();

    void set_defaults();

    template<typename COL_ID_TYPE>
    void parse_column_list(
            const char *columns_str,

            const std::vector<std::string> column_names,

            int num_column_names,

            std::vector<COL_ID_TYPE> &columns,
            
            bool allow_noname=false);

    void postprocess();

    void cleanup();

    void init_input_column_names();

    void init_output_column_descriptions();

    void init_track_column_descriptions_and_units();

    void init_defaults();

    void setup();

    void verify_custom_stellar_evolution();
public:
    CommandLineOptions(int argc, char **argv);

    double get_real_value(InCol::InputColumns quantity) const;

    std::istream &input()
    {if(__input_fname->count) return __input_stream; else return std::cin;}

    std::string input_filename() const {return __input_fname->filename[0];}

    std::string output_filename() const {return __output_fname->filename[0];}

    const char *serialized_stellar_evolution() const
    {return __serialized_stellar_evolution->filename[0];}

    const char *eccentricity_expansion() const
    {return __eccentricity_expansion->filename[0];}

    bool start_locked() const {return __start_locked->count>0;}

    bool use_YREC() const {return __use_YREC->count>0;}

    bool input_from_list() const {return __input_file_format.size();}

    const std::vector<InCol::InputColumns> &input_file_format() const
    {return __input_file_format;}

    const std::vector<OutCol::OutputColumns> &output_file_format() const
    {return __output_file_format;}

    const std::list<double> &required_ages() const
    {return __required_ages;}

    const std::string custom_stellar_evolution() const
    {return __custom_stellar_evolution->filename[0];}

    const std::vector<CustomStellarEvolution::Columns>&
        custom_track_format() const {return __track_format;}

    double custom_track_smoothing(CustomStellarEvolution::Columns column)
        const;

    int custom_track_nodes(CustomStellarEvolution::Columns column)
        const;

    bool need_orbit() const {return __need_orbit;}

    operator bool() {return __parsed_ok;}

    ~CommandLineOptions() {cleanup();}
};

void parse_real_list(
        const char *values_str,

        std::list<double> &values);

void output_solution(
        const OrbitSolver &solver,
        
        const BinarySystem &system,

        const std::string &filename,

        const std::vector<OutCol::OutputColumns> &output_file_format,

        double start_age,

        double end_age,
        
        double timestep,
        
        const std::list<double> &required_ages=std::list<double>());

void calculate_evolution(
        const std::vector<double> &real_parameters,
        
        bool start_locked,

        const std::list<double> &required_ages,

        const StellarEvolution &stellar_evolution,

        const std::string &outfname,

        const std::vector<OutCol::OutputColumns> &output_file_format,

        bool need_orbit);

std::string update_run_parameters(
        std::vector<double> &real_parameters,

        bool &start_locked,

        std::list<double> &required_ages,

        const std::vector<InCol::InputColumns> &input_format,

        std::istringstream &line,

        size_t input_lineno);

void run(
        const CommandLineOptions &options,

        const StellarEvolution &stellar_evolution);
        

#endif