MESAIO.h

Go to the documentation of this file.

#ifndef __MESAIO_H
#define __MESAIO_H

#include "../Core/SharedLibraryExportMacros.h"
#include "Interpolator.h"
#include "../IO/IOUtil.h"
#include "../Core/Common.h"
#include "../Core/AstronomicalConstants.h"
#include "../Core/Error.h"
#include "dirent_hacked.h"
#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <cassert>
#include <vector>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/base_object.hpp>

namespace StellarEvolution {

    namespace MESA {

        const double Yprimordial = 0.249;

        const double Yprotosun = 0.2612;

        const double Zprotosun = 0.0150;

        const double Xprotosun = 1.0 - Yprotosun - Zprotosun;

        LIB_LOCAL double metallicity_from_feh(double feh);

        //interpolation parameter.
        LIB_LOCAL double feh_from_metallicity(double metallicity);

        enum Column {
            MTRACK,

            AGE,

            LOG_RSTAR,

            RSTAR,

            LOG_LSTAR,

            LSTAR,

            MRAD,

            RRAD,

            ICONV,

            IRAD,


            NUM_COLUMNS
        };

        class LIB_LOCAL Header {
            private:
                std::vector<std::string> __column_names;

                std::vector<int> __column_numbers;

                void read_column_numbers(std::istream &track,
                        const std::string &filename, unsigned &line_number);

                void set_column_names();
            public:
                Header(std::ifstream &track, const std::string &filename);

                int get_column(MESA::Column quantity) const
                {return __column_numbers[quantity];}

                const std::vector<int> &get_all_columns() const
                {return __column_numbers;}
        };

        

        class LIB_LOCAL EvolutionIterator {
        public:
            EvolutionIterator() : quantity_iter(NUM_QUANTITIES) {}

            std::list<double>::iterator mass_iter;

            std::list<double>::iterator feh_iter;

            std::list< std::valarray<double> >::iterator age_iter;

            std::vector< std::list< std::valarray<double> >::iterator >
                quantity_iter;

            EvolutionIterator(const EvolutionIterator &orig) :
                mass_iter(orig.mass_iter),
                feh_iter(orig.feh_iter),
                age_iter(orig.age_iter),
                quantity_iter(orig.quantity_iter)
            {}

            EvolutionIterator &operator=(const EvolutionIterator &rhs);

            EvolutionIterator &operator++();

            EvolutionIterator operator++(int)
            {EvolutionIterator result(*this); ++(*this); return result;}

            bool operator==(const EvolutionIterator &rhs)
            {return mass_iter == rhs.mass_iter;}

            bool operator!=(const EvolutionIterator &rhs)
            {return !((*this) == rhs);}
        };

        class LIB_PUBLIC Interpolator : public StellarEvolution::Interpolator {
        private:

            static const std::vector<QuantityID> __column_to_quantity;

            static const std::vector<double> __default_smoothing;

            static const std::vector<int> __default_nodes;

            static const std::vector<bool> __default_vs_log_age;

            static const std::vector<bool> __default_log_quantity;

            std::list<double> __mass_list;

            std::list<double> __feh_list;

            std::list< std::valarray<double> > __track_ages;

            std::vector< std::list< std::valarray<double> > >
                __track_quantities;

            bool parse_model_file_name(const std::string &filename);

            void sort_last_track_by_age();

            void read_model_file(const std::string &filename);

#ifndef NDEBUG
            void log_current_age_ranges() const;
#endif

            void get_mass_feh_grid(
                std::valarray<double> &masses,

                std::valarray<double> &feh
            );

            EvolutionIterator begin();

            EvolutionIterator end();

            void move(EvolutionIterator &dest, EvolutionIterator &source);

            void sort_tracks();
        public:
            Interpolator() {};

            Interpolator(
                const std::string &model_directory,

                unsigned num_threads,

                const std::vector<double> &smoothing = __default_smoothing,

                const std::vector<int> &nodes = __default_nodes,

                const std::vector<bool> &vs_log_age = __default_vs_log_age,

                const std::vector<bool> &log_quantity =__default_log_quantity
            );

            static double default_smoothing(
                StellarEvolution::QuantityID quantity
            )
            {return __default_smoothing[quantity];}

            static const std::vector<double> &default_smoothing()
            {return __default_smoothing;}

            static int default_nodes(
                StellarEvolution::QuantityID quantity
            )
            {return __default_nodes[quantity];}

            static const std::vector<int> &default_nodes()
            {return __default_nodes;}

            static bool default_vs_log_age(
                StellarEvolution::QuantityID quantity
            )
            {return __default_vs_log_age[quantity];}

            static const std::vector<bool> &default_vs_log_age()
            {return __default_vs_log_age;}

            static bool default_log_quantity(
                StellarEvolution::QuantityID quantity
            )
            {return __default_log_quantity[quantity];}

            static const std::vector<bool> &default_log_quantity()
            {return __default_log_quantity;}
        };

    } //End MESA namespace.

} //End StellarEvolution namespace.

std::ostream &operator<<(std::ostream &os,
                         StellarEvolution::MESA::Column col);

#endif