.. _program_listing_file_src_tracks_Tracks3D.hpp:

Program Listing for File Tracks3D.hpp
=====================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_tracks_Tracks3D.hpp>` (``src/tracks/Tracks3D.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   
   #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