Program Listing for File Tracks3D.hpp

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

#ifndef TRACKS3D_HPP
#define TRACKS3D_HPP

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

namespace tracks
{

    class Tracks3D : public std::enable_shared_from_this<Tracks3D>
    {
    public:

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

        // Constructors and destructors

        Tracks3D(
            const std::string& trackName,
            double fehMin,
            double fehMax,
            double vvcrit = defaultVVcrit,
            double afe = defaultAFe,
            const std::string& registryName = defaultRegistry);
        Tracks3D() :
            AFe_(std::numeric_limits<double>::quiet_NaN()),
            vVcrit_(std::numeric_limits<double>::quiet_NaN()),
            fehMin_(std::numeric_limits<double>::quiet_NaN()),
            fehMax_(std::numeric_limits<double>::quiet_NaN())
        { }
        virtual ~Tracks3D() = default;
        Tracks3D(const Tracks3D&) = delete;
        Tracks3D(Tracks3D&&) = default;
        auto operator=(const Tracks3D&) -> Tracks3D& = delete;
        auto operator=(Tracks3D&&) -> Tracks3D& = 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 -> const std::vector<double>& { return FeH_; }

        [[nodiscard]] auto fehMin() const { return fehMin_; }

        [[nodiscard]] auto fehMax() const { return fehMax_; }

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

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

        // Calculation methods

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

       [[nodiscard]] auto liveMassRange(const double t, const double feh) const
       { return interp_->lazySliceConstZ(feh).yLim(t); }

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

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

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

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

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

        [[nodiscard]] auto sliceConstFeH(const double feh) const -> Tracks2D
        {
            Tracks2D::M2DPtr m2d = std::make_unique<
                interp::Mesh2DInterpolator<static_cast<size_t>(FieldIdx::nTrackQty)>>(
                interp_->sliceConstZCopy(feh));
            return { std::move(m2d), feh, AFe_, vVcrit_ };
        }

        [[nodiscard]] auto lazySliceConstFeH(const double feh) const -> Tracks2D
        {
            Tracks2D::M2DPtr m2d = std::make_unique<
                interp::Mesh2DInterpolator<static_cast<size_t>(FieldIdx::nTrackQty)>>(
                interp_->lazySliceConstZ(feh));
            return { std::move(m2d), feh, AFe_, vVcrit_, weak_from_this().lock() };
        }

    private:

        // Track data
        M3DPtr interp_;
        std::vector<double> FeH_;   // NOLINT(readability-identifier-naming)
        double AFe_;               // NOLINT(readability-identifier-naming)
        double vVcrit_;
        double fehMin_;
        double fehMax_;
    };

} // namespace tracks

#endif // TRACKS3D_HPP