JPDFSupportkit.hh

Go to the documentation of this file.

#ifndef __JPHYSICS_JPDFSUPPORTKIT__
#define __JPHYSICS_JPDFSUPPORTKIT__
 
#include <string>
#include <istream>
#include <ostream>
#include <iomanip>
#include <map>
 
#include "JPhysics/JPhysicsSupportkit.hh"
 
#include "Jeep/JProperties.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JPHYSICS {}
namespace JPP { using namespace JPHYSICS; }
 
namespace NAMESPACE {
  extern double getAbsorptionLength(const double lambda);
  extern double getScatteringLength(const double lambda);
  extern double getScatteringProbability(const double x);
  extern double getAngularAcceptance(const double x);
  extern double getQE(const double lambda);
}
 
namespace JPHYSICS {
 
  using JEEP::JProperties;
 
 
  /**
   * Auxiliary method to get preferred key for given value.
   *
   * \param  map                  map
   * \param  key                  preferred key
   * \param  value                target value
   * \return                      key
   */
  template<class T>
  inline std::string getKey(const std::map<std::string, T>& map, const std::string& key, const T& value)
  {
    if (map.count(key) && map.at(key) == value) {
      return key;
    }
 
    for (const auto& i : map) {
      if (i.second == value) {
        return i.first;
      }
    }
 
    return "";
  }
 
 
  /**
   * Auxiliary data structure to customize absorption length. 
   */
  struct JAbsorptionLength :
    public std::map<std::string, double (*)(const double)>
  {
    static constexpr const char* const default_t        =  "default";
    static constexpr const char* const nemo_t           =  "nemo";
    static constexpr const char* const SmithAndBaker_t  =  "SmithAndBaker";
 
 
    /**
     * Default constructor.
     */
    JAbsorptionLength()
    {
      (*this)[default_t]        =  getAbsorptionLengthSmithAndBaker;
      (*this)[nemo_t]           =  NAMESPACE::getAbsorptionLength;
      (*this)[SmithAndBaker_t]  =  getAbsorptionLengthSmithAndBaker;
 
      get_factor()   =    1.0;
      get_offset()   =  610.0;
      get_function() =  (*this)[default_t];
    }
 
 
    /**
     * Read absorption length from input stream.
     *
     * \param  in            input stream
     * \param  object        absorption length
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JAbsorptionLength& object)
    {
      using namespace std;
 
      for (string option; in >> option >> JAbsorptionLength::get_factor() >> JAbsorptionLength::get_offset(); ) {
 
        JAbsorptionLength::const_iterator p = object.find(option);
 
        if (p != object.end())
          JAbsorptionLength::get_function() = p->second;
        else
          in.setstate(ios_base::badbit);
      }
 
      return in;
    }
 
 
    /**
     * Write absorption length to output stream.
     *
     * \param  out           output stream
     * \param  object        absorption length
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JAbsorptionLength& object)
    {
      return out << getKey(object, default_t, get_function())
                 << ' ' << JAbsorptionLength::get_factor()
                 << ' ' << JAbsorptionLength::get_offset();
    }
 
 
    /**
     * Get absorption length.
     *
     * \param  lambda        wavelength of light [nm]
     * \return               absorption length   [m]
     */
    static inline double getAbsorptionLength(const double lambda)
    {
      const double y = 1.0 / (get_factor() * (*get_function())(lambda))  +  1.0 / get_offset();
 
      return 1.0 / y;
    }
 
 
    /**
     * Get reference to multiplication factor.
     *
     * \return               factor
     */
    static double& get_factor()
    {
      static double factor = 1.0;
 
      return factor;
    }
 
 
    /**
     * Get reference to offset.
     *
     * \return               offset
     */
    static double& get_offset()
    {
      static double offset = 1.0e6;
 
      return offset;
    }
 
 
    /**
     * Get reference to global functon.
     *
     * \return               function
     */
    static mapped_type& get_function()
    {
      static mapped_type f1 = NAMESPACE::getAbsorptionLength;
 
      return f1;
    }
  };
  
 
  /**
   * Auxiliary data structure to customize scattering length. 
   */
  struct JScatteringLength :
    public std::map<std::string, double (*)(const double)>
  {
    static constexpr const char* const default_t        =  "default";
 
 
    /**
     * Default constructor.
     */
    JScatteringLength()
    {
      (*this)[default_t]      =  NAMESPACE::getScatteringLength;
 
      get_factor()   =    1.0;
      get_function() =  (*this)[default_t];
    }
 
 
    /**
     * Read scattering length from input stream.
     *
     * \param  in            input stream
     * \param  object        scattering length
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JScatteringLength& object)
    {
      using namespace std;
 
      for (string option; in >> option >> JScatteringLength::get_factor(); ) {
 
        JScatteringLength::const_iterator p = object.find(option);
 
        if (p != object.end())
          JScatteringLength::get_function() = p->second;
        else
          in.setstate(ios_base::badbit);
      }
 
      return in;
    }
 
 
    /**
     * Write scattering length to output stream.
     *
     * \param  out           output stream
     * \param  object        scattering length
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JScatteringLength& object)
    {
      return out << getKey(object, default_t, get_function())
                 << ' ' << JScatteringLength::get_factor();
    }
 
 
    /**
     * Get scattering length.
     *
     * \param  lambda        wavelength of light [nm]
     * \return               scattering length   [m]
     */
    static inline double getScatteringLength(const double lambda)
    {
      return get_factor() * (*get_function())(lambda);
    }
 
 
    /**
     * Get reference to multiplication factor.
     *
     * \return               factor
     */
    static double& get_factor()
    {
      static double factor = 1.0;
 
      return factor;
    }
 
 
    /**
     * Get reference to global functon.
     *
     * \return               function
     */
    static mapped_type& get_function()
    {
      static mapped_type f1 = NAMESPACE::getScatteringLength;
 
      return f1;
    }
  };
 
 
  /**
   * Auxiliary data structure to customize scattering probability. 
   */
  struct JScatteringProbability :
    public std::map<std::string, double (*)(const double)>
  {
    static constexpr const char* const default_t        =  "default";
    static constexpr const char* const f4_t             =  "f4";
    static constexpr const char* const p00075_t         =  "p00075";
    static constexpr const char* const petzhold_t       =  "petzhold";
 
 
    /**
     * Default constructor.
     */
    JScatteringProbability()
    {
      (*this)[default_t]      =  NAMESPACE::getScatteringProbability;
      (*this)[f4_t]           =  f4;
      (*this)[p00075_t]       =  p00075;
      (*this)[petzhold_t]     =  petzhold;
 
      get_weight()   =    1.0;
      get_function() =  (*this)[default_t];
    }
 
 
    /**
     * Read scattering probability from input stream.
     *
     * \param  in            input stream
     * \param  object        scattering probability
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JScatteringProbability& object)
    {
      using namespace std;
 
      for (string option; in >> option >> JScatteringProbability::get_weight(); ) {
 
        JScatteringProbability::const_iterator p = object.find(option);
 
        if (p != object.end())
          JScatteringProbability::get_function() = p->second;
        else
          in.setstate(ios_base::badbit);
      }
 
      return in;
    }
 
 
    /**
     * Write scattering probability to output stream.
     *
     * \param  out           output stream
     * \param  object        scattering probability
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JScatteringProbability& object)
    {
      return out << getKey(object, default_t, get_function())
                 << ' ' << JScatteringProbability::get_weight();
    }
 
 
    /**
     * Get scattering probability.
     *
     * \param  x             cosine scattering angle
     * \return               probability
     */
    static inline double getScatteringProbability(const double x)
    {
      return (1.0 - get_weight()) * rayleigh(x)  +  get_weight() * (*get_function())(x);
    }
 
 
    /**
     * Get reference to weight.
     *
     * \return               weight
     */
    static double& get_weight()
    {
      static double weight = 1.0;
 
      return weight;
    }
 
 
    /**
     * Get reference to global functon.
     *
     * \return             function
     */
    static mapped_type& get_function()
    {
      static mapped_type f1 = NAMESPACE::getScatteringProbability;
 
      return f1;
    }
  };
 
 
  /**
   * Auxiliary data structure to customize PMT angular acceptance. 
   */
  struct JPMTAngularAcceptance :
    public std::map<std::string, double (*)(const double)>
  {
    static constexpr const char* const default_t        =  "default";
 
 
    /**
     * Default constructor.
     */
    JPMTAngularAcceptance()
    {
      (*this)[default_t]      =  NAMESPACE::getAngularAcceptance;
 
      get_function() =  (*this)[default_t];
    }
 
 
    /**
     * Read PMT angular acceptance from input stream.
     *
     * \param  in            input stream
     * \param  object        PMT angular acceptance
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JPMTAngularAcceptance& object)
    {
      using namespace std;
 
      for (string option; in >> option; ) {
 
        JPMTAngularAcceptance::const_iterator p = object.find(option);
 
        if (p != object.end())
          JPMTAngularAcceptance::get_function() = p->second;
        else
          in.setstate(ios_base::badbit);
      }
 
      return in;
    }
 
 
    /**
     * Write PMT angular acceptance to output stream.
     *
     * \param  out           output stream
     * \param  object        PMT angular acceptance
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JPMTAngularAcceptance& object)
    {
      return out << getKey(object, default_t, get_function());
    }
 
 
    /**
     * Get angular acceptance of PMT.
     *
     * \param  x             cosine angle of incidence
     * \return               probability
     */
    static inline double getAngularAcceptance(const double x)
    {
      return (*get_function())(x);
    }
 
 
    /**
     * Get reference to global functon.
     *
     * \return             function
     */
    static mapped_type& get_function()
    {
      static mapped_type f1 = NAMESPACE::getAngularAcceptance;
 
      return f1;
    }
  };
  
 
  /**
   * Auxiliary data structure to customize quantum efficiency. 
   */
  struct JQE :
    public std::map<std::string, double (*)(const double)>
  {
    static constexpr const char* const default_t        =  "default";
 
 
    /**
     * Default constructor.
     */
    JQE()
    {
      (*this)[default_t]      =  NAMESPACE::getQE;
 
      get_factor()   =    1.0;
      get_function() =  (*this)[default_t];
    }
 
 
    /**
     * Read quantum efficiency from input stream.
     *
     * \param  in            input stream
     * \param  object        quantum efficiency
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JQE& object)
    {
      using namespace std;
 
      for (string option; in >> option >> JQE::get_factor(); ) {
 
        JQE::const_iterator p = object.find(option);
 
        if (p != object.end())
          JQE::get_function() = p->second;
        else
          in.setstate(ios_base::badbit);
      }
 
      return in;
    }
 
 
    /**
     * Write quantum efficiency to output stream.
     *
     * \param  out           output stream
     * \param  object        quantum efficiency
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JQE& object)
    {
      return out << getKey(object, default_t, get_function())
                 << ' ' << JQE::get_factor();
    }
 
 
    /**
     * Get quantum efficiency.
     *
     * \param  lambda        wavelength of light [nm]
     * \return               quantum efficiency   [m]
     */
    static inline double getQE(const double lambda)
    {
      return get_factor() * (*get_function())(lambda);
    }
 
 
    /**
     * Get reference to multiplication factor.
     *
     * \return               factor
     */
    static double& get_factor()
    {
      static double factor = 1.0;
 
      return factor;
    }
 
 
    /**
     * Get reference to global functon.
     *
     * \return               function
     */
    static mapped_type& get_function()
    {
      static mapped_type f1 = NAMESPACE::getQE;
 
      return f1;
    }
  };
 
 
  namespace PDF {
    /**
     * Auxiliary data structure for complete configuration.
     */
    struct configuration_type {
 
      JAbsorptionLength       absorptionLength;
      JScatteringLength       scatteringLength;
      JScatteringProbability  scatteringProbability;
      JPMTAngularAcceptance   angularAcceptance;
      JQE                     QE;
 
 
      /**
       * Get properties.
       *
       * \return                 properties
       */
      inline JProperties getProperties()
      {
        JProperties properties;
 
        properties.insert(gmake_property(absorptionLength));
        properties.insert(gmake_property(scatteringLength));
        properties.insert(gmake_property(scatteringProbability));
        properties.insert(gmake_property(angularAcceptance));
        properties.insert(gmake_property(QE));
 
        return properties;
      }
    };
 
 
    /**
     * Manipulator for help output.
     */
    struct help {
      /**
       * Auxiliary data structure to stream configuration to help output.
       */
      struct helper {
        /**
         * Constructor.
         *
         * \param  out             output stream
         */
        helper(std::ostream& out) :
          out(out)
        {}
 
 
        /**
         * Write configuration to output stream.
         *
         * \param  configuration   configuration
         * \return                 output stream
         */
        inline std::ostream& operator<<(const configuration_type& configuration) const
        {
          using namespace std;
          using namespace JPP;
 
          this->out << endl;
          this->out << " possible options absorptionLength: "      << get_keys(configuration.absorptionLength)      << endl;
          this->out << " possible options scatteringLength: "      << get_keys(configuration.scatteringLength)      << endl;
          this->out << " possible options scatteringProbability: " << get_keys(configuration.scatteringProbability) << endl;
          this->out << " possible options angularAcceptance: "     << get_keys(configuration.angularAcceptance)     << endl;
          this->out << " possible options QE: "                    << get_keys(configuration.QE)                    << endl << " ";
 
          return this->out;
        }
 
      private:
        std::ostream& out;
      };
 
 
      /**
       * Transfer output stream to helper.
       *
       * \param  out             output stream
       * \param  help            help
       * \return                 helper
       */
      friend inline helper operator<<(std::ostream& out, const help& help)
      {
        return helper(out);
      }
    };
 
    auto getAbsorptionLength       =  JAbsorptionLength::getAbsorptionLength;
    auto getScatteringLength       =  JScatteringLength::getScatteringLength;
    auto getScatteringProbability  =  JScatteringProbability::getScatteringProbability;
    auto getAngularAcceptance      =  JPMTAngularAcceptance::getAngularAcceptance;
    auto getQE                     =  JQE::getQE;
  }
}
 
#endif