Program Listing for File Tracks2D.hpp

↰ Return to documentation for file (src/tracks/Tracks2D.hpp)

#ifndef TRACKS2D_HPP
#define TRACKS2D_HPP

#include "../interpolation/Mesh2DInterpolator.hpp"
#include "TrackCommons.hpp"
#include <cmath>
#include <cstddef>
#include <limits>
#include <memory>
#include <string>
#include <utility>

namespace tracks
{

    class Tracks2D
    {
    public:

        // Shorten type name
        using M2DPtr = std::unique_ptr<
            interp::Mesh2DInterpolator<
            static_cast<size_t>(FieldIdx::nTrackQty)>>;

        // Constructors and destructors

        Tracks2D(
            const std::string& trackName,
            double feh = 0.0,
            double vvcrit = defaultVVcrit,
            double afe = defaultAFe,
            const std::string& registryName = defaultRegistry);

        Tracks2D(M2DPtr&& m2d, double feH,
            double aFe = std::numeric_limits<double>::quiet_NaN(),
            double vVcrit = std::numeric_limits<double>::quiet_NaN(),
            std::shared_ptr<const void> owner = nullptr)
        : interp_(std::move(m2d)), feH_(feH), aFe_(aFe), vVcrit_(vVcrit),
          owner_(std::move(owner)) {};

        Tracks2D() :
            feH_(std::numeric_limits<double>::quiet_NaN()),
            aFe_(std::numeric_limits<double>::quiet_NaN()),
            vVcrit_(std::numeric_limits<double>::quiet_NaN())
        { }
        virtual ~Tracks2D() = default;
        Tracks2D(const Tracks2D&) = delete;
        Tracks2D(Tracks2D&&) = default;
        auto operator=(const Tracks2D&) -> Tracks2D& = delete;
        auto operator=(Tracks2D&&) -> Tracks2D& = default;

        // Observers

        [[nodiscard]] auto mMin() const { return interp_->yMin(); }

        [[nodiscard]] auto mMax() const { return interp_->yMax(); }

        [[nodiscard]] auto logTMin() const { return interp_->xMin(); }

        [[nodiscard]] auto logTMax() const { return interp_->xMax(); }

        [[nodiscard]] auto feH() const { return feH_; }

        [[nodiscard]] auto aFe() const { return aFe_; }

        [[nodiscard]] auto vVcrit() const { return vVcrit_; }

        // Calculation methods

       [[nodiscard]] auto starLifetime(const double m) const { return std::pow(10.0, interp_->xMax(m)); }

       [[nodiscard]] auto liveMassRange(const double logT) const { return interp_->yLim(logT); }

       [[nodiscard]] auto massAndDerivFromLifetime(const double logT) const
       { return interp_->yEdgeSlope(logT, false); }

       [[nodiscard]] auto isAlive(const double m, const double logT) const -> bool
       { return interp_->contains(logT, m); }

        [[nodiscard]] auto getTrack(const double m) const
        {
            auto track = interp_->interpConstY(m);
            track->setPostProcess(&renormalizeSurfaceAbundances);
            return track;
        }

        [[nodiscard]] auto getIsochrone(const double logT) const
        {
            auto isochrone = interp_->interpConstX(logT);
            for (auto& segment : isochrone) { segment->setPostProcess(&renormalizeSurfaceAbundances); }
            return isochrone;
        }

        [[nodiscard]] auto getStar(const double m, const double logT,
            const bool linear = false) const
        {
            auto props = (*interp_)(logT, m, linear);
            renormalizeSurfaceAbundances(props);
            return props;
        }

    private:

        // Track data
        M2DPtr interp_;
        double feH_;
        double aFe_;
        double vVcrit_;
        std::shared_ptr<const void> owner_;
    };

} // namespace tracks

#endif // TRACKS2D_HPP