JFluxDictionary.hh

Go to the documentation of this file.

#ifndef __JAANET__JFLUXDICTIONARY__
#define __JAANET__JFLUXDICTIONARY__
 
#include <map>
 
#include "JAAnet/JConstantFlux.hh"
#include "JAAnet/JPowerLawFlux.hh"
#include "JAAnet/JHondaFluxInterpolator.hh"
#include "JAAnet/JAtmosphericNeutrinoFlux.hh"
 
#include "JAAnet/JFluxHelper.hh"
 
#include "JOscProb/JOscProbHelper.hh"
 
 
/**
 * \author bjung
 */
namespace JAANET {}
namespace JPP { using namespace JAANET; }
 
namespace JAANET {  
 
  using JOSCPROB::JOscProbHelper;
  
    
  /**
   * Dictionary to map distinct flux function categories to unique identifiers.
   * The identifiers are provided by the enum `fluxes`.
   */
  class JFluxDictionary:
    public std::map<int, JFluxHelper>
  {
  public:
 
    /**
     * Indices of flux factors in flux factor dictionary.
     */
    enum fluxes {
      FLUX_FUNCTIONS_BEGIN       =  0, //!< Start of flux functions
      
      FLAT_FLUX                  =  1, //!< Flat flux
      POWER_LAW_FLUX             =  2, //!< Power-law flux
      ATMOSPHERIC_NEUTRINO_FLUX  =  3, //!< Atmospheric neutrino flux (c.f. `Flux_Atmospheric` in `<jpp>/externals/flux/Flux.hh`)
      HONDA_FLUX                 =  4, //!< Interpolated azimuth-averaged Honda flux
      
      FLUX_FUNCTIONS_END         = 99  //!< End of flux functions
    };
 
 
    /**
     * Constructor.
     *
     * \param  oscProb           oscillation probability calculator
     */
    JFluxDictionary(const JOscProbHelper& oscProb) :
      oscProb(oscProb)
    {
      using namespace std;
      
      const JHondaFluxInterpolator2D<> interpolator;
 
      this->insert(make_pair(FLAT_FLUX,                 make_shared<JConstantFlux>()));
      this->insert(make_pair(POWER_LAW_FLUX,            make_shared<JPowerLawFlux>()));
      this->insert(make_pair(ATMOSPHERIC_NEUTRINO_FLUX, make_shared<JAtmosphericNeutrinoFlux>(oscProb)));
      this->insert(make_pair(HONDA_FLUX,                make_shared<JOscFlux>(interpolator, oscProb)));
    }  
    
    
    /**
     * Default constructor.
     */
    JFluxDictionary() :
      JFluxDictionary(JOscProbHelper())
    {}
 
 
    /**
     * Look-up function.
     *
     * \param  identifier        flux category ID
     */
    const JFlux& at(const int identifier) const
    {
      using namespace std;
      using namespace JPP;
 
      const_iterator i = this->find(identifier);
 
      if (i != this->cend()) {
        return i->second.getFlux();
      } else {
        THROW(JValueOutOfRange, "JFluxDictionary::at(): Invalid identifier " << identifier);
      }
    }
 
 
    /**
     * Look-up operator.
     *
     * \param  identifier        flux category ID
     */
    const JFlux& operator[](const int identifier) const
    {
      return this->at(identifier);
    }
 
    
  private:
 
    JOscProbHelper oscProb; //!< Oscillation probability calculator
  };
}
  
#endif