JEvtCategoryHelper.hh

Go to the documentation of this file.

#ifndef __JAANET__JEVTCATEGORYHELPER__
#define __JAANET__JEVTCATEGORYHELPER__
 
#include <memory>
 
#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Evt.hh"
 
#include "JLang/JComparable.hh"
 
#include "JAAnet/JHead.hh"
#include "JAAnet/JEvtCategory.hh"
#include "JAAnet/JMuonBundleCategory.hh"
#include "JAAnet/JNeutrinoInteractionCategory.hh"
 
 
/**
 * \author bjung
 */
 
namespace JAANET {}
namespace JPP { using namespace JAANET; }
 
namespace JAANET {
 
  using JLANG::JComparable;
  
 
  /**
   * Helper class for event categories.
   */
  struct JEvtCategoryHelper :
    public std::shared_ptr<JEvtCategory>,
    public JComparable<JEvtCategoryHelper>
  {
    typedef std::shared_ptr<JEvtCategory>   pointer_type;
    
    /**
     * Default constructor.
     */
    JEvtCategoryHelper() :
      pointer_type()
    {}
    
    
    /**
     * Constructor.
     *
     * \param  p                 shared pointer to event category
     */
    JEvtCategoryHelper(const pointer_type& p) :
      pointer_type(p)
    {}
    
    
    /**
     * Constructor.
     *
     * \param  category          event category
     */
    JEvtCategoryHelper(const JEvtCategory& category)
    {
      this->configure(category);
    }
 
 
    /**
     * Constructor.
     *
     * \param  header            MC header
     */
    JEvtCategoryHelper(const JHead& header)
    {
      this->configure(header);
    }
 
 
    /**
     * Constructor.
     *
     * \param  type              PDG type
     */
    JEvtCategoryHelper(const int type)
    {
      this->configure(type);
    }
 
 
    /**
     * Configuration.
     *
     * \param  p                 shared pointer to event category
     */
    void configure(const pointer_type& p)
    {
      static_cast<pointer_type&>(*this) = p;
    }
    
    
    /**
     * Configuration.
     *
     * \param  category          event category
     */
    void configure(const JEvtCategory& category)
    {
      reset(category.clone());      
    }
    
    
    /**
     * Configuration.
     *
     * \param  category          event category
     */
    void configure(const JHead& header)
    {
      using namespace JPP;
      
      if        (is_neutrino_primary(header.primary.type)) {
        reset(new JNeutrinoInteractionCategory(header));
      } else if (is_muon_bundle_primary(header.primary.type)) {
        reset(new JMuonBundleCategory(header));
      } else {
        THROW(JValueOutOfRange, "JEvtCategoryHelper::configure(): Cannot construct event category for given header with primary ID " << header.primary.type);
      }
    }
 
 
    /**
     * Configuration.
     *
     * \param  type              PDG type
     */
    void configure(const int type)
    {
      using namespace JPP;
      
      if        (is_neutrino_primary(type)) {
        reset(new JNeutrinoInteractionCategory(type));
      } else if (is_muon_bundle_primary(type)) {
        reset(new JMuonBundleCategory(type));
      } else {
        THROW(JValueOutOfRange, "JEvtCategoryHelper::configure(): Cannot construct event category for PDG type " << type);
      }
    }
    
    
    /**
     * Get reference to event category.
     *
     * \return                    reference to event category
     */
    JEvtCategory& getEvtCategory() const
    {
      using namespace JPP;
 
      if (static_cast<const JEvtCategoryHelper&>(*this)) {
        return *(this->get());
      } else {
        THROW(JNullPointerException, "JEvtCategoryHelper::getEvtCategory(): Event category is not set.");
      }
    }
 
    
    /**
     * Check if event category is valid.
     *
     * \return                    true if event category is valid; else false
     */
    bool is_valid() const
    {
      return static_cast<const JEvtCategoryHelper&>(*this) && this->get()->is_valid();
    }
    
    
    /**
     * Check whether given MC header matches with this event category.
     *
     * \param  header            MC header
     * \return                   true if matching; else false
     */
    bool match(const JHead& header) const
    {
      const JEvtCategory& category = getEvtCategory();
 
      return category.match(header);
    }
    
 
    /**
     * Check whether given event matches with this event category.
     *
     * \param  event             event
     * \return                   true if matching; else false
     */
    bool match(const Evt& event) const
    {
      const JEvtCategory& category = getEvtCategory();
 
      return category.match(event);
    }
 
 
    /**
     * Less-than method.
     *
     * \param  category          event category
     * \return                   true if this event category is less than given event category; else false
     */
    bool less(const JEvtCategory& category) const
    {
      const JEvtCategory& cat = getEvtCategory();
 
      return cat.less(category);
    }
 
 
    /**
     * Less-than method.
     *
     * \param  helper            shared pointer to event category
     * \return                   true if this event category is less than given event category; else false
     */
    bool less(const JEvtCategoryHelper& helper) const
    {
      return this->less(helper.getEvtCategory());
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  equation        equation parameters
     */
    JProperties getProperties(const JEquationParameters& equation = JEvtCategory::getEquationParameters()) const
    {
      const JEvtCategory& cat = getEvtCategory();
 
      return cat.getProperties();
    }
 
 
    /**
     * Read event category from input.
     *
     * \param  in                 input stream
     * \param  object             event category
     * \return                    input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JEvtCategoryHelper& object)
    {
      using namespace std;
 
      if (object) {
 
        return object.get()->read(in);
        
      } else {
 
        streampos pos = in.tellg();
        
        int type = 0;
 
        if (in >> type) {
          object.configure(type);
          return in;
        }
 
        in.clear();
        in.seekg(pos);
 
        JNeutrinoInteractionCategory neutrinoInteraction;
        neutrinoInteraction.getProperties().read(in);
 
        if (neutrinoInteraction.is_valid()) {
          object.configure(neutrinoInteraction);
          return in;
        }
 
        in.clear();
        in.seekg(pos);
 
        JMuonBundleCategory muonBundle;
        muonBundle.getProperties().read(in);    
        
        if (muonBundle.is_valid()) {
          object.configure(muonBundle);
        }
        
        return in;
      }
    }
 
 
    /** 
     * Write event category to output.
     *
     * \param  out                output stream
     * \param  object             event  category
     * \return                    output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JEvtCategoryHelper& object)
    {
      if (object.is_valid()) {
        return out << object.getEvtCategory();
      } else {
        return out << 0;
      }
    }
  };
}
 
#endif