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"
 
/**
 * \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 getQE(const double lambda);
}
 
namespace JPHYSICS {
 
  /**
   * Auxiliary data structure to define pointer to global function.
   */
  struct JAbsorptionLength_t {
    typedef double (*pF)(const double);                    // type definition of pointer to global function
  };
  
 
  /**
   * Auxiliary data structure to customize absorption length. 
   */
  struct JAbsorptionLength :
    public JAbsorptionLength_t,
    public std::map<std::string, JAbsorptionLength_t::pF>
  {
    /**
     * Default constructor.
     */
    JAbsorptionLength()
    {
      (*this)["default"]        =  NAMESPACE::getAbsorptionLength;
      (*this)["SmithAndBaker"]  =  getAbsorptionLengthSmithAndBaker;
    }
 
 
    /**
     * Read absorption length from input stream.
     *
     * \param  in            input stream
     * \param  absorption    absorption length
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JAbsorptionLength& absorption)
    {
      using namespace std;
 
      for (string option; in >> option >> JAbsorptionLength::get_factor() >> JAbsorptionLength::get_offset(); ) {
 
        JAbsorptionLength::const_iterator p = absorption.find(option);
 
        if (p != absorption.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  absorption    absorption length
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JAbsorptionLength& absorption)
    {
      for (const_iterator i = absorption.begin(); i != absorption.end(); ++i) {
        if (i->second == JAbsorptionLength::get_function()) {
          out << i->first << ' ';
        }
      }
      
      return out << 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 pF& get_function()
    {
      static pF f1 = NAMESPACE::getAbsorptionLength;
 
      return f1;
    }
  };
 
 
  /**
   * Auxiliary data structure to define pointer to global function.
   */
  struct JScatteringLength_t {
    typedef double (*pF)(const double);                    // type definition of pointer to global function
  };
  
 
  /**
   * Auxiliary data structure to customize scattering length. 
   */
  struct JScatteringLength :
    public JScatteringLength_t,
    public std::map<std::string, JScatteringLength_t::pF>
  {
    /**
     * Default constructor.
     */
    JScatteringLength()
    {
      (*this)["default"]      =  NAMESPACE::getScatteringLength;
    }
 
 
    /**
     * Read scattering length from input stream.
     *
     * \param  in            input stream
     * \param  scattering    scattering length
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JScatteringLength& scattering)
    {
      using namespace std;
 
      for (string option; in >> option >> JScatteringLength::get_factor(); ) {
 
        JScatteringLength::const_iterator p = scattering.find(option);
 
        if (p != scattering.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  scattering    scattering length
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JScatteringLength& scattering)
    {
      for (const_iterator i = scattering.begin(); i != scattering.end(); ++i) {
        if (i->second == JScatteringLength::get_function()) {
          out << i->first << ' ';
        }
      }
      
      return out << 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 pF& get_function()
    {
      static pF f1 = NAMESPACE::getScatteringLength;
 
      return f1;
    }
  };
 
 
  /**
   * Auxiliary data structure to define pointer to global function.
   */
  struct JScatteringProbability_t {
    typedef double (*pF)(const double);                    // type definition of pointer to global function
  };
  
 
  /**
   * Auxiliary data structure to customize scattering probability. 
   */
  struct JScatteringProbability :
    public JScatteringProbability_t,
    public std::map<std::string, JScatteringProbability_t::pF>
  {
    /**
     * Default constructor.
     */
    JScatteringProbability()
    {
      (*this)["default"]      =  NAMESPACE::getScatteringProbability;
      (*this)["f4"]           =  f4;
      (*this)["p00075"]       =  p00075;
      (*this)["petzhold"]     =  petzhold;
    }
 
 
    /**
     * Read scattering probability from input stream.
     *
     * \param  in            input stream
     * \param  scattering    scattering probability
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JScatteringProbability& scattering)
    {
      using namespace std;
 
      for (string option; in >> option >> JScatteringProbability::get_weight(); ) {
 
        JScatteringProbability::const_iterator p = scattering.find(option);
 
        if (p != scattering.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  scattering    scattering probability
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JScatteringProbability& scattering)
    {
      for (const_iterator i = scattering.begin(); i != scattering.end(); ++i) {
        if (i->second == JScatteringProbability::get_function()) {
          out << i->first << ' ';
        }
      }
      
      return out << 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 pF& get_function()
    {
      static pF f1 = NAMESPACE::getScatteringProbability;
 
      return f1;
    }
  };
 
 
  /**
   * Auxiliary data structure to define pointer to global function.
   */
  struct JQE_t {
    typedef double (*pF)(const double);                    // type definition of pointer to global function
  };
  
 
  /**
   * Auxiliary data structure to customize quantum efficiency. 
   */
  struct JQE :
    public JQE_t,
    public std::map<std::string, JQE_t::pF>
  {
    /**
     * Default constructor.
     */
    JQE()
    {
      (*this)["default"]      =  NAMESPACE::getQE;
    }
 
 
    /**
     * Read quantum efficiency from input stream.
     *
     * \param  in            input stream
     * \param  scattering    quantum efficiency
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JQE& scattering)
    {
      using namespace std;
 
      for (string option; in >> option >> JQE::get_factor(); ) {
 
        JQE::const_iterator p = scattering.find(option);
 
        if (p != scattering.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  scattering    quantum efficiency
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JQE& scattering)
    {
      for (const_iterator i = scattering.begin(); i != scattering.end(); ++i) {
        if (i->second == JQE::get_function()) {
          out << i->first << ' ';
        }
      }
      
      return out << 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 pF& get_function()
    {
      static pF f1 = NAMESPACE::getQE;
 
      return f1;
    }
  };
}
 
#endif