.. _program_listing_file_src_tracks_Tracks2D.hpp:

Program Listing for File Tracks2D.hpp
=====================================

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

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

.. code-block:: cpp

   
   #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