JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t > Class Template Reference

Template definition for Honda flux table interpolator. More...

#include <JHondaFluxInterpolator.hh>

Inheritance diagram for JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >:

Classes
struct	JHondaFluxInterpolatorHelper
	Auxiliary class for I/O of Honda flux interpolator. More...

Public Types
enum	{ NUMBER_OF_DIMENSIONS = multifunction_type::NUMBER_OF_DIMENSIONS }
typedef JMAPLIST< JEnergyFunctionalMap_t, JCoszFunctionalMap_t >::maplist	JFunctionalMaplist_t
typedef JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >	interpolator_type
typedef JMultiFunction< JPhiFunction_t, JFunctionalMaplist_t >	multifunction_type
typedef multifunction_type::abscissa_type	abscissa_type
typedef multifunction_type::argument_type	argument_type
typedef multifunction_type::result_type	result_type
typedef multifunction_type::value_type	value_type
typedef multifunction_type::multimap_type	multimap_type
typedef multifunction_type::super_const_iterator	super_const_iterator
typedef multifunction_type::super_iterator	super_iterator
typedef multifunction_type::function_type	function_type
typedef JRange< abscissa_type >	JRange_t
enum	{ NUMBER_OF_DIMENSIONS = JMapLength<JMaplist_t>::value + JFunction_t::NUMBER_OF_DIMENSIONS }
typedef multimap_type::ordinate_type	ordinate_type
typedef multimap_type::const_iterator	const_iterator
typedef multimap_type::const_reverse_iterator	const_reverse_iterator
typedef multimap_type::iterator	iterator
typedef multimap_type::reverse_iterator	reverse_iterator
typedef JClonable< JClonable_t >::clone_type	clone_type

Public Member Functions
	JHondaFluxInterpolator ()
	Default constructor.
	JHondaFluxInterpolator (const char *fileName)
	Constructor.
void	load (const char *const fileName)
	Load oscillation probability table from file.
bool	is_valid () const override final
	Check whether this interpolator is valid.
double	getFactor (const int type, const double log10E, const double costh, const double phi) const
	Get diffuse flux for given particle PDG-identifier, energy, cosine zenith angle and azimuth angle.
double	getFlux (const int type, const double log10E, const double costh, const double phi) const
	Get flux of given event.
double	operator() (const int type, const double log10E, const double costh, const double phi) const
	Get diffuse flux for given particle PDG-identifier, energy, cosine zenith angle and azimuth angle.
double	getFactor (const Evt &evt) const override final
	Get flux of given event.
double	getFlux (const Evt &event) const
	Get flux of given event.
JProperties	getProperties (const JEquationParameters &eqpars=JEvtWeightFactor::getEquationParameters()) override final
	Get properties of this class.
JProperties	getProperties (const JEquationParameters &eqpars=JEvtWeightFactor::getEquationParameters()) const override final
	Get properties of this class.
std::istream &	read (std::istream &in) override final
	Stream input.
const JMultiFunction &	getMultiFunction () const
	Get multidimensional function.
JMultiFunction &	getMultiFunction ()
	Get multidimensional function.
template<class __JFunction_t , class __JMaplist_t , class __JDistance_t >
void	insert (const JMultiFunction< __JFunction_t, __JMaplist_t, __JDistance_t > &input)
	Insert multidimensional input.
template<class JHistogram_t , class __JMaplist_t , class __JDistance_t >
void	insert (const JMultiHistogram< JHistogram_t, __JMaplist_t, __JDistance_t > &input)
	Insert multidimensional input.
void	compile ()
	Compilation.
void	setExceptionHandler (const typename function_type::supervisor_type &supervisor)
	Set the supervisor for handling of exceptions.
template<class ... Args>
result_type	operator() (const Args &...args) const
	Multi-dimensional interpolation method call.
virtual clone_type	clone () const override
	Get clone of this object.

Static Public Attributes
static int	debug = 0
	debug level (default is off).

Protected Member Functions
template<unsigned int N, class __JAbscissa_t , class __JContents_t , template< class, class, class > class __JMap_t, class __JDistance_t >
void	insert (const JMultiKey< N, argument_type > &key, const JHistogramMap< __JAbscissa_t, __JContents_t, __JMap_t, __JDistance_t > &input)
	Insert multidimensional histogram at multidimensional key.
template<class __JElement_t , template< class, class > class __JContainer_t, class __JDistance_t >
void	insert (const JMultiKey< JMapLength< JMaplist_t >::value, argument_type > &key, const JHistogram1D< __JElement_t, __JContainer_t, __JDistance_t > &input)
	Convert one-dimensional histogram to PDF and insert result at given multidimensional key.
template<class JHistogram_t , class __JMaplist_t , class __JDistance_t >
void	insert (const JMultiKey< JMapLength< JMaplist_t >::value, argument_type > &key, const JMultiHistogram< JHistogram_t, __JMaplist_t, __JDistance_t > &input)
	Convert multidimensional histogram to PDF and insert result at given multidimensional key.

Protected Attributes
JArray< NUMBER_OF_DIMENSIONS, argument_type >	buffer

Private Attributes
std::string	table
	Table filename.
JRange_t	coszRange
	Zenith angle range.
JRange_t	phiRange
	Azimuth angle range [deg].

Detailed Description

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>
class JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >

Template definition for Honda flux table interpolator.

Definition at line 193 of file JHondaFluxInterpolator.hh.

Member Typedef Documentation

JFunctionalMaplist_t

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

JMAPLIST<JEnergyFunctionalMap_t,JCoszFunctionalMap_t>::maplist JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::JFunctionalMaplist_t

Definition at line 200 of file JHondaFluxInterpolator.hh.

interpolator_type

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

JHondaFluxInterpolator<JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t> JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::interpolator_type

Definition at line 202 of file JHondaFluxInterpolator.hh.

multifunction_type

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

JMultiFunction<JPhiFunction_t, JFunctionalMaplist_t> JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::multifunction_type

Definition at line 203 of file JHondaFluxInterpolator.hh.

abscissa_type

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

multifunction_type::abscissa_type JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::abscissa_type

Definition at line 207 of file JHondaFluxInterpolator.hh.

argument_type

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

multifunction_type::argument_type JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::argument_type

Definition at line 208 of file JHondaFluxInterpolator.hh.

result_type

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

multifunction_type::result_type JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::result_type

Definition at line 209 of file JHondaFluxInterpolator.hh.

value_type

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

multifunction_type::value_type JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::value_type

Definition at line 210 of file JHondaFluxInterpolator.hh.

multimap_type

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

multifunction_type::multimap_type JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::multimap_type

Definition at line 212 of file JHondaFluxInterpolator.hh.

super_const_iterator

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

multifunction_type::super_const_iterator JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::super_const_iterator

Definition at line 214 of file JHondaFluxInterpolator.hh.

super_iterator

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

multifunction_type::super_iterator JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::super_iterator

Definition at line 215 of file JHondaFluxInterpolator.hh.

function_type

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

multifunction_type::function_type JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::function_type

Definition at line 216 of file JHondaFluxInterpolator.hh.

JRange_t

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

JRange<abscissa_type> JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::JRange_t

Definition at line 218 of file JHondaFluxInterpolator.hh.

ordinate_type

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

multimap_type::ordinate_type JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::ordinate_type

inherited

Definition at line 57 of file JMultiFunction.hh.

const_iterator

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

multimap_type::const_iterator JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::const_iterator

inherited

Definition at line 60 of file JMultiFunction.hh.

const_reverse_iterator

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

multimap_type::const_reverse_iterator JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::const_reverse_iterator

inherited

Definition at line 61 of file JMultiFunction.hh.

iterator

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

multimap_type::iterator JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::iterator

inherited

Definition at line 62 of file JMultiFunction.hh.

reverse_iterator

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

multimap_type::reverse_iterator JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::reverse_iterator

inherited

Definition at line 63 of file JMultiFunction.hh.

clone_type

template<class JClonable_t , class JDerived_t >

JClonable<JClonable_t>::clone_type JLANG::JClonable< JClonable_t, JDerived_t >::clone_type

inherited

Definition at line 61 of file JClonable.hh.

Member Enumeration Documentation

anonymous enum

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

anonymous enum

Enumerator
NUMBER_OF_DIMENSIONS

Definition at line 205 of file JHondaFluxInterpolator.hh.

{ NUMBER_OF_DIMENSIONS = multifunction_type::NUMBER_OF_DIMENSIONS };

anonymous enum

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

anonymous enum

inherited

Enumerator
NUMBER_OF_DIMENSIONS

Definition at line 49 of file JMultiFunction.hh.

{ NUMBER_OF_DIMENSIONS = JMapLength<JMaplist_t>::value + JFunction_t::NUMBER_OF_DIMENSIONS };

Constructor & Destructor Documentation

JHondaFluxInterpolator() [1/2]

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::JHondaFluxInterpolator ( )

inline

Default constructor.

Definition at line 224 of file JHondaFluxInterpolator.hh.

                             :
      table(),
      coszRange(0.0, -1.0),
      phiRange (0.0, -1.0)
    {}

JHondaFluxInterpolator() [2/2]

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::JHondaFluxInterpolator ( const char * fileName )

inline

Constructor.

Parameters

fileName

oscillation probability table filename

Definition at line 236 of file JHondaFluxInterpolator.hh.

                                                 :
      JHondaFluxInterpolator()
    {
      this->load(fileName);
      this->check_validity();
    }

Member Function Documentation

load()

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

void JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::load ( const char *const fileName )

inline

Load oscillation probability table from file.

Parameters

fileName

oscillation probability table filename

Definition at line 249 of file JHondaFluxInterpolator.hh.

    {
      using namespace std;
      using namespace JPP;
 
      try {
        
        NOTICE("Loading Honda flux table from file " << fileName << "... " << flush);
 
        multimap_type& zmap = static_cast<multimap_type&>(*this);
 
        ifstream ifs(fileName);
      
        JHondaAngularBinSpecs binspecs;
        
        for (string line; getline(ifs, line); ) {
 
          double energy = 0.0;
        
          result_type values;
 
          istringstream iss1(line);
 
          const double cosz = binspecs.coszRange.getCentralValue();
          const double phi  = binspecs.phiRange .getCentralValue();
 
          coszRange.include(cosz);
          phiRange .include(phi);
          
          if (iss1 >> energy >> values) {
            
            const double log10E = log10(energy);
 
            for (typename result_type::iterator i = values.begin(); i != values.end(); ++i) {
              *i = log(*i);
            }
 
            zmap[log10E][cosz][phi] = values;
            
          } else {
 
            const size_t p1 = line.find (HONDA_BINSPECS_BEGIN);
            const size_t p2 = line.rfind(HONDA_BINSPECS_END);
        
            if (p1 != string::npos && p2 != string::npos) {
 
              const string binspecstr = line.substr(p1 + 1, p2 - p1 - 1);
            
              istringstream iss2(binspecstr);
            
              iss2 >> binspecs;
            }
          }
        }
      }
      catch(const exception& error) {
        THROW(JFileReadException, "JHondaFluxInterpolator::load(): Error reading file " << fileName);   
      }
    }

is_valid()

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

bool JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::is_valid ( ) const

inlinefinaloverride

Check whether this interpolator is valid.

Returns

true if valid; else false

Definition at line 315 of file JHondaFluxInterpolator.hh.

    {
      return this->size() > 0 && coszRange.getLength() > 0.0 && phiRange.getLength() > 0.0;
    }

getFactor() [1/2]

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

double JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::getFactor ( const int type, const double log10E, const double costh, const double phi ) const

inline

Get diffuse flux for given particle PDG-identifier, energy, cosine zenith angle and azimuth angle.

Parameters

type	PDG particle type
log10E	logarithmic neutrino energy [GeV]
costh	cosine zenith angle
phi	azimuth angle (defined clockwise w.r.t. the North) [deg]

Returns

diffuse flux [GeV^-1 * m^-2 * sr^-1 * s^-1]

< [–]

< [deg]

< Honda azimuth angle is defined counterclockwise w.r.t. the South
(c.f. arXiv:1102.2688), so a conversion is necessary.

Definition at line 330 of file JHondaFluxInterpolator.hh.

    {
      using namespace std;
      using namespace JPP;
 
      static const double epsilon_costh = 1.0e-3; //!< [--]
      static const double epsilon_phi   = 1.0;    //!< [deg]
 
      static const JRange_t mod(0.0, 360.0);
      
      const multifunction_type& function = static_cast<const multifunction_type&>(*this);
 
      const double _costh = min(max(costh, -1.0), 1.0);
      const double _phi   = mod.mod(180.0 - phi); //!< Honda azimuth angle is defined counterclockwise w.r.t. the South\n
                                                  //!< (c.f. arXiv:1102.2688), so a conversion is necessary.
      
      result_type lnFluxes;
      
      if (coszRange(_costh) && phiRange(_phi)) {
        
        lnFluxes = function(log10E, _costh, _phi);
        
      } else { // Perform linear extrapolation for edges of angular ranges
        
        if        (_costh > coszRange.getUpperLimit() && phiRange(_phi)) {
 
          const abscissa_type x1 = coszRange.getUpperLimit();
          const abscissa_type x2 = coszRange.getUpperLimit() - epsilon_costh;
            
          const result_type&  y1 = function(log10E, x1, _phi);  
          const result_type&  y2 = function(log10E, x2, _phi);
 
          lnFluxes = y1 + ((y2 - y1) / (x2 - x1)) * (_costh - x1);
          
        } else if (_costh < coszRange.getLowerLimit() && phiRange(_phi)) {
        
          const abscissa_type x1 = coszRange.getLowerLimit();
          const abscissa_type x2 = coszRange.getLowerLimit() + epsilon_costh;
            
          const result_type&  y1 = function(log10E, x1, _phi);  
          const result_type&  y2 = function(log10E, x2, _phi);
 
          lnFluxes = y1 + ((y2 - y1) / (x2 - x1)) * (_costh - x1);
        
        } else if (coszRange(_costh) && _phi > phiRange.getUpperLimit()) {
 
          const abscissa_type x1 = phiRange.getUpperLimit();
          const abscissa_type x2 = phiRange.getUpperLimit() - epsilon_costh;
            
          const result_type&  y1 = function(log10E, _costh, x1);        
          const result_type&  y2 = function(log10E, _costh, x2);
 
          lnFluxes = y1 + ((y2 - y1) / (x2 - x1)) * (_phi - x1);
        
        } else if (coszRange(_costh) && _phi < phiRange.getLowerLimit()) {
 
          const abscissa_type x1 = phiRange.getLowerLimit();
          const abscissa_type x2 = phiRange.getLowerLimit() + epsilon_costh;
            
          const result_type&  y1 = function(log10E, _costh, x1);        
          const result_type&  y2 = function(log10E, _costh, x2);
 
          lnFluxes = y1 + ((y2 - y1) / (x2 - x1)) * (_phi - x1);
        
        } else if (_costh > coszRange.getUpperLimit() && _phi > phiRange.getUpperLimit()) {
 
          const abscissa_type c1 = coszRange.getUpperLimit();
          const abscissa_type c2 = coszRange.getUpperLimit() - epsilon_costh;
          
          const abscissa_type p1 = phiRange .getUpperLimit();
          const abscissa_type p2 = phiRange .getUpperLimit() - epsilon_phi;
 
          const result_type&  y1 = function(log10E, c1, p1);
          const result_type&  y2 = function(log10E, c2, p2);
 
          lnFluxes = y1 + ((y2 - y1) / (c2 - c1) / (p2 - p1)) * (_costh - p1) * (_phi - p1);
          
        } else if (_costh > coszRange.getUpperLimit() && _phi < phiRange.getUpperLimit()) {
 
          const abscissa_type c1 = coszRange.getUpperLimit();
          const abscissa_type c2 = coszRange.getUpperLimit() - epsilon_costh;
          
          const abscissa_type p1 = phiRange .getLowerLimit();
          const abscissa_type p2 = phiRange .getLowerLimit() + epsilon_phi;
 
          const result_type&  y1 = function(log10E, c1, p1);
          const result_type&  y2 = function(log10E, c2, p2);
 
          lnFluxes = y1 + ((y2 - y1) / (c2 - c1) / (p2 - p1)) * (_costh - p1) * (_phi - p1);
          
        } else if (_costh < coszRange.getLowerLimit() && phi > phiRange.getUpperLimit()) {
 
          const abscissa_type c1 = coszRange.getLowerLimit();
          const abscissa_type c2 = coszRange.getLowerLimit() + epsilon_costh;
          
          const abscissa_type p1 = phiRange .getUpperLimit();
          const abscissa_type p2 = phiRange .getUpperLimit() - epsilon_phi;
 
          const result_type&  y1 = function(log10E, c1, p1);
          const result_type&  y2 = function(log10E, c2, p2);
 
          lnFluxes = y1 + ((y2 - y1) / (c2 - c1) / (p2 - p1)) * (_costh - p1) * (_phi - p1);
          
        } else {
 
          const abscissa_type c1 = coszRange.getLowerLimit();
          const abscissa_type c2 = coszRange.getLowerLimit() + epsilon_costh;
          
          const abscissa_type p1 = phiRange .getLowerLimit();
          const abscissa_type p2 = phiRange .getLowerLimit() + epsilon_phi;
 
          const result_type&  y1 = function(log10E, c1, p1);
          const result_type&  y2 = function(log10E, c2, p2);
 
          lnFluxes = y1 + ((y2 - y1) / (c2 - c1) / (p2 - p1)) * (_costh - p1) * (_phi - p1);
        }
      }
 
      switch(type) {
      case TRACK_TYPE_NUMU:
        return exp(lnFluxes[0]);
      case TRACK_TYPE_ANTINUMU:
        return exp(lnFluxes[1]);
      case TRACK_TYPE_NUE:
        return exp(lnFluxes[2]);
      case TRACK_TYPE_ANTINUE:
        return exp(lnFluxes[3]);
      default:
        return 0.0;
      }
    }

getFlux() [1/2]

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

double JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::getFlux ( const int type, const double log10E, const double costh, const double phi ) const

inline

Get flux of given event.

Parameters

type	PDG particle type
log10E	logarithmic neutrino energy [GeV]
costh	cosine zenith angle
phi	azimuth angle (defined clockwise w.r.t. the North) [deg]

Returns

diffuse flux [GeV^-1 * m^-2 * sr^-1 * s^-1]

Definition at line 475 of file JHondaFluxInterpolator.hh.

    {
      return getFactor(type, log10E, costh, phi);
    }

operator()() [1/2]

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

double JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::operator() ( const int type, const double log10E, const double costh, const double phi ) const

inline

Get diffuse flux for given particle PDG-identifier, energy, cosine zenith angle and azimuth angle.

Parameters

type	PDG particle type
log10E	logarithmic neutrino energy [GeV]
costh	cosine zenith angle
phi	azimuth angle (defined clockwise w.r.t. the North) [deg]

Returns

diffuse flux [GeV^-1 * m^-2 * sr^-1 * s^-1]

Definition at line 493 of file JHondaFluxInterpolator.hh.

    {
      return getFactor(type, log10E, costh, phi);
    }

getFactor() [2/2]

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

double JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::getFactor ( const Evt & evt ) const

inlinefinaloverride

Get flux of given event.

Parameters

evt

event

Returns

flux [GeV^-1 * m^-2 * sr^-1 * s^-1]

< The gSeaGen azimuth angle is defined clockwise w.r.t. the North (c.f. arXiv:2003.14040)

Definition at line 508 of file JHondaFluxInterpolator.hh.

    {
      const Trk& neutrino = get_neutrino(evt);
      
      const double log10E = log10(neutrino.E);
      const double costh  = neutrino.dir.z;
      
      //!< The gSeaGen azimuth angle is defined clockwise w.r.t. the North (c.f. arXiv:2003.14040)
      const double phi = atan(neutrino.dir.y / neutrino.dir.x) * 180.0 / M_PI;
 
      return getFactor(neutrino.type, log10E, costh, phi);
    }

getFlux() [2/2]

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

double JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::getFlux ( const Evt & event ) const

inline

Get flux of given event.

Parameters

evt

event

Returns

flux [GeV^-1 * m^-2 * sr^-1 * s^-1]

Definition at line 528 of file JHondaFluxInterpolator.hh.

    {
      return getFactor(event);
    }

getProperties() [1/2]

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

JProperties JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::getProperties ( const JEquationParameters & eqpars = JEvtWeightFactor::getEquationParameters() )

inlinefinaloverride

Get properties of this class.

Parameters

eqpars

equation parameters

Definition at line 539 of file JHondaFluxInterpolator.hh.

    {
      return JHondaFluxInterpolatorHelper(*this, eqpars);
    }

getProperties() [2/2]

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

JProperties JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::getProperties ( const JEquationParameters & eqpars = JEvtWeightFactor::getEquationParameters() ) const

inlinefinaloverride

Get properties of this class.

Parameters

eqpars

equation parameters

Definition at line 550 of file JHondaFluxInterpolator.hh.

    {
      return JHondaFluxInterpolatorHelper(*this, eqpars);
    }

read()

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

std::istream & JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::read ( std::istream & in )

inlinefinaloverride

Stream input.

Parameters

in	input stream

Returns

input stream

Definition at line 562 of file JHondaFluxInterpolator.hh.

    {
      using namespace std;
 
      streampos pos = in.tellg();      
 
      if (!(in >> table)) {
 
        in.clear();
        in.seekg(pos);
        
        JProperties properties = getProperties();
        
        in >> properties;
      }
 
      load(table.c_str());
      
      this->check_validity();
      
      return in;
    }

getMultiFunction() [1/2]

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

const JMultiFunction & JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::getMultiFunction ( ) const

inlineinherited

Get multidimensional function.

Returns

this multidimensional function

Definition at line 98 of file JMultiFunction.hh.

    {
      return static_cast<const JMultiFunction&>(*this);
    }

getMultiFunction() [2/2]

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

JMultiFunction & JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::getMultiFunction ( )

inlineinherited

Get multidimensional function.

Returns

this multidimensional function

Definition at line 109 of file JMultiFunction.hh.

    {
      return static_cast<JMultiFunction&>(*this);
    }

insert() [1/5]

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

template<class __JFunction_t , class __JMaplist_t , class __JDistance_t >

void JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::insert ( const JMultiFunction< __JFunction_t, __JMaplist_t, __JDistance_t > & input )

inlineinherited

Insert multidimensional input.

Parameters

input

multidimensional function

Definition at line 121 of file JMultiFunction.hh.

    {
      copy(input, *this);
    }

insert() [2/5]

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

template<class JHistogram_t , class __JMaplist_t , class __JDistance_t >

void JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::insert ( const JMultiHistogram< JHistogram_t, __JMaplist_t, __JDistance_t > & input )

inlineinherited

Insert multidimensional input.

Parameters

input

multidimensional histogram

Definition at line 133 of file JMultiFunction.hh.

    {
      this->insert(JMultiKey<0, argument_type>(), input);
    }

insert() [3/5]

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

template<unsigned int N, class __JAbscissa_t , class __JContents_t , template< class, class, class > class __JMap_t, class __JDistance_t >

void JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::insert ( const JMultiKey< N, argument_type > & key, const JHistogramMap< __JAbscissa_t, __JContents_t, __JMap_t, __JDistance_t > & input )

inlineprotectedinherited

Insert multidimensional histogram at multidimensional key.

Parameters

key	multidimensional key
input	multidimensional histogram

Definition at line 196 of file JMultiFunction.hh.

    {
      if (input.size() > 1) {
 
        for (auto j = input.begin(), i = j++; j != input.end(); ++i, ++j) {
          
          const argument_type x = 0.5 * (i->getX() + j->getX());
 
          insert(JMultiKey<N+1, argument_type>(key, x), i->getY());
        }
      }
    }

insert() [4/5]

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

template<class __JElement_t , template< class, class > class __JContainer_t, class __JDistance_t >

void JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::insert ( const JMultiKey< JMapLength< JMaplist_t >::value, argument_type > & key, const JHistogram1D< __JElement_t, __JContainer_t, __JDistance_t > & input )

inlineprotectedinherited

Convert one-dimensional histogram to PDF and insert result at given multidimensional key.

Parameters

key	multidimensional key
input	histogram

Definition at line 218 of file JMultiFunction.hh.

    {
      JFunction_t buffer;
      
      makePDF(input, buffer);
      
      multimap_type::insert(key, buffer);
    }    

insert() [5/5]

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

template<class JHistogram_t , class __JMaplist_t , class __JDistance_t >

void JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::insert ( const JMultiKey< JMapLength< JMaplist_t >::value, argument_type > & key, const JMultiHistogram< JHistogram_t, __JMaplist_t, __JDistance_t > & input )

inlineprotectedinherited

Convert multidimensional histogram to PDF and insert result at given multidimensional key.

Parameters

key	multidimensional key
input	multidimensional histogram

Definition at line 237 of file JMultiFunction.hh.

    {
      JFunction_t buffer;
      
      makePDF(input, buffer);
      
      multimap_type::insert(key, buffer);
    }    

compile()

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

void JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::compile ( )

inlineinherited

Compilation.

Definition at line 142 of file JMultiFunction.hh.

    {
      this->for_each(compiler);
 
      for (super_iterator i = this->super_begin(); i != this->super_end(); ++i) {
        (*i).getValue().compile();
      }
    }

setExceptionHandler()

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

void JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::setExceptionHandler ( const typename function_type::supervisor_type & supervisor )

inlineinherited

Set the supervisor for handling of exceptions.

Parameters

supervisor

supervisor

Definition at line 157 of file JMultiFunction.hh.

    {
      this->for_each(supervisor);
 
      for (super_iterator i = this->super_begin(); i != this->super_end(); ++i) {
        (*i).getValue().setExceptionHandler(supervisor);
      }
    }

operator()() [2/2]

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

template<class ... Args>

result_type JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::operator() ( const Args &... args ) const

inlineinherited

Multi-dimensional interpolation method call.

Parameters

args	comma seperated list of abscissa values

Returns

function value

Definition at line 174 of file JMultiFunction.hh.

    {
      buffer.set(args...);
 
      return this->evaluate(buffer.data());
    }

clone()

template<class JClonable_t , class JDerived_t >

virtual clone_type JLANG::JClonable< JClonable_t, JDerived_t >::clone ( ) const

inlineoverridevirtualinherited

Get clone of this object.

Returns

pointer to newly created object

Reimplemented in JPHYSICS::JPD0Transformer_t< JArgument_t >, JPHYSICS::JPDFTransformer< 2, JArgument_t >, JPHYSICS::JPDFTransformer< 3, JArgument_t >, JPHYSICS::JPDFTransformer< 4, JArgument_t >, JPHYSICS::JPDFTransformer< 5, JArgument_t >, JPHYSICS::JPDFTransformer_t< JArgument_t >, JPHYSICS::JPDGTransformer_t< JArgument_t >, and JTOOLS::JMultiMapTransformer< N, JArgument_t >::JMultiMapDefaultTransformer.

Definition at line 69 of file JClonable.hh.

    {
      return new JDerived_t(static_cast<const JDerived_t&>(*this));
    }

Member Data Documentation

table

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

std::string JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::table

private

Table filename.

Definition at line 612 of file JHondaFluxInterpolator.hh.

coszRange

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

JRange_t JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::coszRange

private

Zenith angle range.

Definition at line 614 of file JHondaFluxInterpolator.hh.

phiRange

template<class JPhiFunction_t = JConstantFunction1D<double, JArray<4, double> >, template< class, class, class > class JCoszFunctionalMap_t = JPolint1FunctionalMap, template< class, class, class > class JEnergyFunctionalMap_t = JPolint1FunctionalMap>

JRange_t JAANET::JHondaFluxInterpolator< JPhiFunction_t, JCoszFunctionalMap_t, JEnergyFunctionalMap_t >::phiRange

private

Azimuth angle range [deg].

Definition at line 615 of file JHondaFluxInterpolator.hh.

buffer

template<class JFunction_t , class JMaplist_t , class JDistance_t = JDistance<typename JFunction_t::argument_type>>

JArray<NUMBER_OF_DIMENSIONS, argument_type> JTOOLS::JMultiFunction< JFunction_t, JMaplist_t, JDistance_t >::buffer

mutableprotectedinherited

Definition at line 183 of file JMultiFunction.hh.

debug

template<class T >

int JEEP::JMessage< T >::debug = 0

staticinherited

debug level (default is off).

Definition at line 45 of file JMessage.hh.

---

The documentation for this class was generated from the following file:

• JHondaFluxInterpolator.hh