.. _program_listing_file_src_specsyn_SpecsynLibChained.hpp:

Program Listing for File SpecsynLibChained.hpp
==============================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_specsyn_SpecsynLibChained.hpp>` (``src/specsyn/SpecsynLibChained.hpp``)

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

.. code-block:: cpp

   
   #ifndef SPECSYNLIBCHAINED_HPP
   #define SPECSYNLIBCHAINED_HPP
   
   #include "../io/SimControls.hpp"
   #include "Specsyn.hpp"
   #include "SpecsynCommons.hpp"
   #include <array>
   #include <cstddef>
   #include <memory>
   #include <string>
   #include <utility>
   #include <vector>
   
   namespace specsyn
   {
   
       class SpecsynLibChained : public Specsyn
       {
       public:
   
           SpecsynLibChained(
               const std::vector<std::string>& spectraName,
               double fehMin,
               double fehMax,
               double afe,
               double cfe,
               const std::vector<double>& microTurb,
               double r,
               const std::string& registryName,
               double wlMin,
               double wlMax,
               std::size_t nWl,
               bool tClamp,
               const io::SimControls& controls);
   
           [[nodiscard]] auto spec(const StarData& props, double feh) const
           -> std::vector<double> override;
   
           [[nodiscard]] auto specForIntegration(const StarData& props, double feh) const
           -> std::vector<double> override;
   
           [[nodiscard]] static auto makeCommonWlGrid(
               const std::vector<std::vector<double>>& wlGrids) -> std::vector<double>;
   
           [[nodiscard]] auto wnlTeffRanges() const -> const std::array<std::pair<double, double>, 3>&
           {
               return wnlTeffRanges_;
           }
   
           [[nodiscard]] auto normalLogTeffMax() const -> double { return normalLogTeffMax_; }
   
       private:
   
           void propagateWNLTeffRanges();
   
           void updateFeHRanges();
   
           void updateLoggRanges();
   
           [[nodiscard]] auto clampFehForLibrary(
               double feh, double logg, GridType type, std::size_t libIdx) const -> std::pair<double, double>;
   
           [[nodiscard]] static auto propsWithClampedLogg(
               StarData props, double currentLogg, double clampedLogg) -> StarData;
   
           void warnIfFeHClamped(double fehMin, double fehMax) const;
   
           [[nodiscard]] auto chainFor(GridType type) const -> const std::vector<std::unique_ptr<Specsyn>>&;
   
           [[nodiscard]] auto clampNormalLogTeffFloor(StarData props, GridType type) const -> StarData;
   
           std::vector<std::unique_ptr<Specsyn>> wrLibs_;
   
           std::vector<std::unique_ptr<Specsyn>> wdLibs_;
   
           std::vector<std::unique_ptr<Specsyn>> normalLibs_;
   
           static constexpr std::size_t nGridType = static_cast<std::size_t>(GridType::nGridType);
   
           std::array<double, nGridType> logTeffMin_;
           std::array<double, nGridType> logTeffMax_; 
           std::array<double, nGridType> loggMin_;
           std::array<double, nGridType> loggMax_; 
           std::array<std::pair<double, double>, 3> wnlTeffRanges_;
   
           double normalLogTeffMax_;
   
           std::array<std::vector<double>, nGridType> fehMin_;
           std::array<std::vector<double>, nGridType> fehMax_; 
           std::array<std::vector<double>, nGridType> loggLibMin_;
           std::array<std::vector<double>, nGridType> loggLibMax_; 
           std::array<std::vector<std::string>, nGridType> libNames_;
       };
   
   } // namespace specsyn
   
   #endif // SPECSYNLIBCHAINED_HPP