JEvtCategory.hh

Go to the documentation of this file.

#ifndef __JAANET__JEVTCATEGORY__
#define __JAANET__JEVTCATEGORY__
 
#include "km3net-dataformat/offline/Evt.hh"
 
#include "Jeep/JProperties.hh"
 
#include "JLang/JClonable.hh"
#include "JLang/JException.hh"
#include "JLang/JStringStream.hh"
 
#include "JSystem/JStat.hh"
 
#include "JAAnet/JHead.hh"
 
 
/**
 * \author bjung
 */
 
namespace JAANET {}
namespace JPP { using namespace JAANET; }
 
namespace JAANET {
 
  using JEEP::JProperties;
  
  using JLANG::JClonable;
  using JLANG::JComparable;
  
 
  /**
   * Low-level interface for event categories.
   */
  struct JEvtCategory :
    public JClonable  <JEvtCategory>,
    public JComparable<JEvtCategory>    
  {
    /**
     * Default constructor.
     */
    JEvtCategory() :
      primaryType(0)
    {}
 
 
    /**
     * Constructor.
     * 
     * \param  primaryType        primary PDG type
     */
    JEvtCategory(const int primaryType) :
      primaryType(primaryType)
    {}
    
    
    /**
     * Virtual destructor.
     */
    virtual ~JEvtCategory()
    {}
 
 
    /**
     * Check if event category is valid.
     *
     * \return                    true if event category is valid; else false
     */
    virtual bool is_valid() const = 0;
    
 
    /**
     * Check validity.
     */
    inline void check_validity() const
    {
      using namespace JPP;
        
      if (!is_valid()) {
        THROW(JValueOutOfRange, "JEvtCategory::check_validity(): Invalid category " << *this);
      }
    }
 
 
    /**
     * Check whether given MC header matches with this event category.
     *
     * \param  header            MC header
     * \return                   true if matching; else false
     */
    virtual bool match(const JHead& header) const = 0;
    
 
    /**
     * Check whether given event matches with this event category.
     *
     * \param  event             event
     * \return                   true if matching; else false
     */
    virtual bool match(const Evt& event) const = 0;
 
 
    /**
     * Less-than method.
     *
     * \param  category          event category
     * \return                   true if this event category is less than given event category; else false
     */
    virtual inline bool less(const JEvtCategory& category) const
    {
      return this->primaryType < category.getPrimaryType();
    }
 
 
    /**
     * Get primary PDG type of this event category.
     *
     * \return                   primary PDG type
     */
    int getPrimaryType() const
    {
      return primaryType;
    }
    
    
    /**
     * Get equation parameters.
     *
     * \return                   equation parameters
     */
    static inline JEquationParameters& getEquationParameters()
    {
      static JEquationParameters eqpars("=", ",", "./", "#");
 
      return eqpars;
    }
      
 
    /**
     * Set equation parameters.
     *
     * \param  eqpars            equation parameters
     */
    static inline void setEquationParameters(const JEquationParameters& eqpars)
    {
      getEquationParameters() = eqpars;
    }
 
    
    /**
     * Get properties of this class.
     *
     * \param  eqpars            equation parameters
     */
    virtual JProperties getProperties(const JEquationParameters& eqpars = JEvtCategory::getEquationParameters()) {
      
      JProperties properties(eqpars,1);
      
      properties.insert(gmake_property(primaryType));
 
      return properties;
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars            equation parameters
     */
    virtual JProperties getProperties(const JEquationParameters& eqpars = JEvtCategory::getEquationParameters()) const
    {
      JProperties properties(eqpars,1);
      
      properties.insert(gmake_property(primaryType));
 
      return properties;
    }
    
 
    /**
     * Read event category from input.
     *
     * \param  in                input stream
     * \return                   input stream
     */
    virtual std::istream& read(std::istream& in)
    {
      using namespace std;
      using namespace JPP;
 
      JStringStream is(in);
 
      if (getFileStatus(is.str().c_str())) {
        is.load();
      }
 
      JProperties properties = getProperties();
      is >> properties;
      
      check_validity();
      
      return in;      
    }
 
 
    /**
     * Write event category to output
     *
     *
     * \param  out               output stream
     * \return                   output stream
     */
    virtual std::ostream& write(std::ostream& out) const
    {
      return out << 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, JEvtCategory& object)
    {
      return object.read(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 JEvtCategory& object)
    {
      return object.write(out);
    }
 
 
  protected:
 
    int primaryType; //!< Event primary PDG type
  };
}
 
#endif