JOscillogram.hh

Go to the documentation of this file.

#ifndef __JOSCPROB__JOSCILLOGRAM__
#define __JOSCPROB__JOSCILLOGRAM__

#include <iostream>
#include <iomanip>
#include <string>

#include "JLang/JException.hh"

#include "JTools/JGrid.hh"

#include "JOscProb/JOscChannel.hh"
#include "JOscProb/JOscProbToolkit.hh"
#include "JOscProb/JOscProbInterpolatorInterface.hh"


/**
 * \author bjung, mdejong
 */

namespace JOSCPROB {}
namespace JPP { using namespace JOSCPROB; }

namespace JOSCPROB {

  using JLANG::JValueOutOfRange;
  using JLANG::JNullPointerException;

  using JTOOLS::JGrid;
  

  /**
   * Auxiliary class for defining an oscillogram axis.
   */
  struct JOscillogramAxis :
    public JGrid<double>
  {
    typedef JGrid<double>     JGrid_t;


    /**
     * Constructor.
     *
     * \param  type               oscillation variable type
     * \param  binning            oscillation variable binning
     */
    JOscillogramAxis(const int     type,
                     const JGrid_t binning) :
      JGrid_t(binning),
      type   (type)
    {}

    
    /**
     * Constructor.
     *
     * \param  type               oscillogram variable type
     * \param  N                  number of bins
     * \param  min                minimum axis value
     * \param  max                maximum axis value
     */
    JOscillogramAxis(const int    type,
                     const int    N,
                     const double min,
                     const double max) :
      JGrid_t(N, min, max),
      type   (type)
    {}

    
    int type; //!< axis type
  };
  
  
  /**
   * Auxiliary class for creating oscillograms.
   */
  struct JOscillogram
  {
    /**
     * Constructor.
     *
     * \param  abscissa           oscillogram abscissa axis definition
     * \param  ordinate           oscillogram ordinate axis definition
     * \param  channel            oscillation channel
     * \param  pInterpolator      pointer to oscillation probability interpolator
     */
    JOscillogram(const JOscillogramAxis&              abscissa,
                 const JOscillogramAxis&              ordinate,
                 const JOscChannel&                   channel,
                 const JOscProbInterpolatorInterface* pInterpolator) :
      abscissa     (abscissa),
      ordinate     (ordinate),
      channel      (channel),
      pInterpolator(pInterpolator)
    {
      if (pInterpolator == NULL) {
        THROW(JNullPointerException, "JOscillogram::JOscillogram(...): Oscillation probability interpolator is not set");
      }
    }

    
    /**
     * Constructor.
     *
     * \param  abscissaName       oscillogram abscissa variable name
     * \param  abscissaBinning    oscillogram abscissa binning
     * \param  ordinateName       oscillogram ordinate variable name
     * \param  ordinateBinning    oscillogram ordinate binning
     * \param  channel            oscillation channel
     * \param  pInterpolator      pointer to oscillation probability interpolator
     */
    JOscillogram(const std::string&                   abscissaName,
                 const JGrid<double>                  abscissaBinning,
                 const std::string&                   ordinateName,     
                 const JGrid<double>                  ordinateBinning,   
                 const JOscChannel&                   channel,
                 const JOscProbInterpolatorInterface* pInterpolator) :
      abscissa     (JOscVars::getType(abscissaName), abscissaBinning),
      ordinate     (JOscVars::getType(ordinateName), ordinateBinning),
      channel      (channel),
      pInterpolator(pInterpolator)
    {
      if (pInterpolator == NULL) {
        THROW(JNullPointerException, "JOscillogram::JOscillogram(...): Oscillation probability interpolator is not set");
      }
    }

    
    /**
     * Get energy corrresponding to the given bin indices.
     *
     * \param  i                  abscissa bin index
     * \param  j                  ordinate bin index
     * \return                    energy [GeV]
     */
    double getEnergy(const int i, const int j) const
    {
      const std::pair<double, double>& result = getTransformation(i, j);

      return result.first;
    }


    /**
     * Get cosine zenith angle corrresponding to the given bin indices.
     *
     * \param  i                  abscissa bin index
     * \param  j                  ordinate bin index
     * \return                    energy [GeV]
     */
    double getCosth(const int i, const int j) const
    {
      const std::pair<double, double>& result = getTransformation(i, j);

      return result.second;
    }


    /**
     * Get oscillation probability for given bin indices.
     *
     * \param  i                  abscissa bin index
     * \param  j                  ordinate bin index
     * \return                    oscillation probability
     */
    double getP(const int i, const int j) const
    {
      const double& energy = getEnergy(i, j);
      const double& costh  = getCosth (i, j);
      
      return (*pInterpolator)(channel, energy, costh);
    }

    
  private:
    

    /**
     * Get energy and cosine zenith angle corresponding to the given bin indices.
     *
     * \param  i                  abscissa bin index
     * \param  j                  ordinate bin index
     * \return                    transformed coordinate (E [GeV], costh)
     */
    std::pair<double, double> getTransformation(const int i, const int j) const
    {
      using namespace std;
      
      static const JBaselineCalculator& baselineCalculator = pInterpolator->getBaselineCalculator();
      
      static int ix = -1;
      static int iy = -1;

      static pair<double, double> result = {0.0, 0.0}; // Cache result

      if (i != ix || j != iy) {

        ix = i;
        iy = j;
        
        const double x = abscissa.getX(i);
        const double y = ordinate.getX(j);

        switch (ordinate.type) {
        case (int) JOscVars::COSTH:
          result.second = y;
          break;
        case (int) JOscVars::SINTH:
          result.second = sqrt((1 + y) * (1 - y));
          break;
        case (int) JOscVars::BASELINE:
          result.second = baselineCalculator.getCosth(y);
          break;
        default:
          THROW(JValueOutOfRange, "JOscillogram::getCosth(const double): Invalid ordinate type " << ordinate.type);
        }

        switch (abscissa.type) {
        case (int) JOscVars::ENERGY:
          result.first = x;
          break;
        case (int) JOscVars::LOG10E:
          result.first = pow(10.0, x);
          break;
        case (int) JOscVars::LOE:
          result.first = (x > 0.0 ? baselineCalculator.getBaseline(result.second) / x : 0.0);
          break;
        default:
          THROW(JValueOutOfRange, "JOscillogram::getEnergy(const double, const double): Invalid abscissa type " << abscissa.type);      
        }
      }

      return result;
    }
    
    
    JOscillogramAxis abscissa; //!< Abscissa axis
    JOscillogramAxis ordinate; //!< Ordinate axis

    JOscChannel      channel;  //!< Oscillation channel

    const JOscProbInterpolatorInterface* pInterpolator; //!< Pointer to oscillation probability interpolator
  };
}

#endif