JOscChannel.hh

Go to the documentation of this file.

#ifndef __JOSCPROB__JOSCCHANNEL__
#define __JOSCPROB__JOSCCHANNEL__

#include "km3net-dataformat/offline/Trk.hh"

#include "JLang/JException.hh"
#include "JLang/JComparable.hh"

#include "Jeep/JProperties.hh"


/**
 * \author bjung
 * \file
 * Oscillation parameters and auxiliary methods.
 */

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

namespace JOSCPROB {

  using JLANG::JEquationParameters;
  
  
  /**
   * Neutrino oscillation channel.
   */  
  struct JOscChannel :
    public JLANG::JComparable<JOscChannel>
  {
    /**
     * Neutrino flavours.
     */
    enum JFlavour_t      { ELECTRON           = 12,
                           MUON               = 14,
                           TAU                = 16,
                           FLAVOUR_UNDEFINED  =  0 };

    /**
     * Charge parities.
     */
    enum JChargeParity_t { ANTIPARTICLE       = -1,
                           PARTICLE           = +1,
                           CPARITY_UNDEFINED  =  0 };
    

    /**
     * Default constructor.
     */
    JOscChannel() :
      in     (FLAVOUR_UNDEFINED),
      out    (FLAVOUR_UNDEFINED),
      Cparity(CPARITY_UNDEFINED)
    {}


    /**
     * Constructor.                             
     *
     * \param  in              input  flavour
     * \param  out             output flavour
     * \param  Cparity         charge parity
     */
    JOscChannel(const JFlavour_t      in,
                const JFlavour_t      out,
                const JChargeParity_t Cparity) :
      in (in),
      out(out),
      Cparity(Cparity)
    {}


    /**
     * Less-than method
     *
     * \param  channel         channel
     * \return                 true this channel less than given channel; else false 
     */
    inline bool less(const JOscChannel& channel) const
    {
      if (this->Cparity == channel.Cparity) {
        
        if (this->in == channel.in) {
          
          return this->out < channel.out;
          
        } else {
          
          return this->in < channel.in;
        }
        
      } else {
        
        return this->Cparity < channel.Cparity;
      }
    }


    /**
     * Write channel to output.
     *
     * \param  out           output stream
     * \param  object        oscillation channel
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JOscChannel& object)
    {
      return out << object.getProperties();
    }


    /** 
     * Read channel from input.
     *
     * \param  in            input stream
     * \param  object        oscillation channel
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JOscChannel& object)
    {

      JProperties properties(object.getProperties());

      in >> properties;

      object.setProperties(properties);
      
      return in;
    }


    /**
     * Get flavour of neutrino.
     *
     * \param  pdgID               PDG identifier
     * \return                     flavour
     */
    static inline JFlavour_t getFlavour(const int pdgID)
    {
      using namespace JPP;

      switch(abs(pdgID)) {
      case (int) ELECTRON:
        return ELECTRON;
      case (int) MUON:
        return MUON;
      case (int) TAU:
        return TAU;
      default:
        return FLAVOUR_UNDEFINED;
      }
    }
  
  
    /**
     * Get flavour of neutrino.
     *
     * \param  neutrino            neutrino track
     */
    static inline JFlavour_t getFlavour(const Trk& neutrino)
    {
      return getFlavour(neutrino.type);
    }


    /**
     * Get charge-parity of given neutrino.
     *
     * \param  Cparity             charge parity (1 for neutrinos; -1 for anti-neutrinos)
     * \return                     oscillation channel charge parity
     */
    static inline JChargeParity_t getChargeParity(const int Cparity)
    {
      switch (Cparity) {
      case ((int) PARTICLE):
        return PARTICLE;
      case ((int) ANTIPARTICLE):
        return ANTIPARTICLE;
      default:
        return CPARITY_UNDEFINED;
      }
    }


    /**
     * Get charge-parity of given neutrino.
     *
     * \param  neutrino            neutrino track
     * \return                     charge-parity (1 for neutrinos; -1 for anti-neutrinos)
     */
    static inline JChargeParity_t getChargeParity(const Trk& neutrino)
    {
      return getChargeParity(neutrino.type / abs(neutrino.type));
    }
  

    /**
     * Auxiliary function to retrieve incoming neutrino PDG type.
     *
     * \param  channel             oscillation channel
     * \return                     incoming neutrino PDG type
     */
    static inline int getIncomingNeutrinoType(const JOscChannel& channel)
    {
      switch (channel.in) {
      case ELECTRON:
        return (int)channel.Cparity * (int)ELECTRON;
      case MUON:
        return (int)channel.Cparity * (int)MUON;
      case TAU:
        return (int)channel.Cparity * (int)TAU;
      default:
        THROW(JLANG::JValueOutOfRange, "getIncomingNeutrinoType(): Invalid oscillation channel " << channel);   
      }
    }


    /**
     * Auxiliary function to retrieve outgoing neutrino PDG type.
     *
     * \param  channel           oscillation channel
     * \return                   outgoing neutrino PDG type
     */
    static inline int getOutgoingNeutrinoType(const JOscChannel& channel)
    {
      switch (channel.out) {
      case ELECTRON:
        return (int)channel.Cparity * (int)ELECTRON;
      case MUON:
        return (int)channel.Cparity * (int)MUON;
      case TAU:
        return (int)channel.Cparity * (int)TAU;
      default:
        THROW(JLANG::JValueOutOfRange, "getOutgoingNeutrinoType(): Invalid oscillation channel " << channel);
      }
    }


    /**
     * Get equation parameters.
     *
     * \return                 equation parameters
     */
    static inline JEquationParameters& getEquationParameters()
    {
      static JEquationParameters equation("=", "\n\r;,", "./", "#");

      return equation;
    }
      

    /**
     * Set equation parameters.
     *
     * \param  equation        equation parameters
     */
    static inline void setEquationParameters(const JEquationParameters& equation)
    {
      getEquationParameters() = equation;
    }

    
    /**
     * Get properties of this class.
     *
     * \param  equation        equation parameters
     */
    JProperties getProperties(const JEquationParameters& equation = JOscChannel::getEquationParameters())
    {
      return JOscChannelHelper(*this, equation);
    }


    /**
     * Get properties of this class.
     *
     * \param  equation        equation parameters
     */
    JProperties getProperties(const JEquationParameters& equation = JOscChannel::getEquationParameters()) const
    {
      return JOscChannelHelper(*this, equation);
    }


    /**
     * Set properties of this class
     *
     * \param  properties      properties
     */
    void setProperties(const JProperties& properties)
    {
      this->in      = JOscChannel::getFlavour     (properties.getValue<int>("in"));
      this->out     = JOscChannel::getFlavour     (properties.getValue<int>("out"));
      this->Cparity = JOscChannel::getChargeParity(properties.getValue<int>("Cparity"));
    }


    JFlavour_t      in;      //!< Incoming  flavour
    JFlavour_t      out;     //!< Outcoming flavour
    JChargeParity_t Cparity; //!< Charge-parity

    
  private:
    /**
     * Auxiliary class for I/O of oscillation channel.
     */
    struct JOscChannelHelper :
      public JProperties
    {
      /**
       * Constructor.
       *
       * \param  object        oscillation channel
       * \param  equation      equation    parameters 
       */
      template<class JOscChannel_t>
      JOscChannelHelper(JOscChannel_t&             object,
                        const JEquationParameters& equation) :
        JProperties(equation, 1),
        in         (object.in),
        out        (object.out),
        Cparity    (object.Cparity)
      {
        this->insert(gmake_property(in));
        this->insert(gmake_property(out));
        this->insert(gmake_property(Cparity));
      }

      int in;
      int out;
      int Cparity;
    };
  };


  /**
   * Declare group of neutrino oscillation channels.
   */
  static const JOscChannel getOscChannel[]  =  {
    JOscChannel(JOscChannel::ELECTRON,  JOscChannel::ELECTRON,  JOscChannel::PARTICLE),
    JOscChannel(JOscChannel::ELECTRON,  JOscChannel::MUON,      JOscChannel::PARTICLE),
    JOscChannel(JOscChannel::ELECTRON,  JOscChannel::TAU,       JOscChannel::PARTICLE),
    JOscChannel(JOscChannel::MUON,      JOscChannel::ELECTRON,  JOscChannel::PARTICLE),
    JOscChannel(JOscChannel::MUON,      JOscChannel::MUON,      JOscChannel::PARTICLE),
    JOscChannel(JOscChannel::MUON,      JOscChannel::TAU,       JOscChannel::PARTICLE),
    JOscChannel(JOscChannel::TAU,       JOscChannel::ELECTRON,  JOscChannel::PARTICLE),
    JOscChannel(JOscChannel::TAU,       JOscChannel::MUON,      JOscChannel::PARTICLE),
    JOscChannel(JOscChannel::TAU,       JOscChannel::TAU,       JOscChannel::PARTICLE),
    JOscChannel(JOscChannel::ELECTRON,  JOscChannel::ELECTRON,  JOscChannel::ANTIPARTICLE),
    JOscChannel(JOscChannel::ELECTRON,  JOscChannel::MUON,      JOscChannel::ANTIPARTICLE),
    JOscChannel(JOscChannel::ELECTRON,  JOscChannel::TAU,       JOscChannel::ANTIPARTICLE),
    JOscChannel(JOscChannel::MUON,      JOscChannel::ELECTRON,  JOscChannel::ANTIPARTICLE),
    JOscChannel(JOscChannel::MUON,      JOscChannel::MUON,      JOscChannel::ANTIPARTICLE),
    JOscChannel(JOscChannel::MUON,      JOscChannel::TAU,       JOscChannel::ANTIPARTICLE),
    JOscChannel(JOscChannel::TAU,       JOscChannel::ELECTRON,  JOscChannel::ANTIPARTICLE),
    JOscChannel(JOscChannel::TAU,       JOscChannel::MUON,      JOscChannel::ANTIPARTICLE),
    JOscChannel(JOscChannel::TAU,       JOscChannel::TAU,       JOscChannel::ANTIPARTICLE)
  };


  /**
   * Number of neutrino oscillation channels.
   */
  static const int NUMBER_OF_OSCCHANNELS = sizeof(getOscChannel) / sizeof(JOscChannel);
}

#endif