RecRpcTrigger.h

Go to the documentation of this file.

//   **************************************************************************
//   *                                                                        *
//   *                      ! ! ! A T T E N T I O N ! ! !                     *
//   *                                                                        *
//   *  This file was created automatically by GaudiObjDesc, please do not    *
//   *  delete it or edit it by hand.                                         *
//   *                                                                        *
//   *  If you want to change this file, first change the corresponding       *
//   *  xml-file and rerun the tools from GaudiObjDesc (or run make if you    *
//   *  are using it from inside a Gaudi-package).                            *
//   *                                                                        *
//   **************************************************************************

#ifndef RecEvent_RecRpcTrigger_H
#define RecEvent_RecRpcTrigger_H 1

// Include files
#include "Event/RecRpcCluster.h"
#include "Event/RecRpcTrack.h"
#include "Conventions/Detectors.h"
#include "Context/TimeStamp.h"
#include "Conventions/Trigger.h"
#include "GaudiKernel/boost_allocator.h"
#include "GaudiKernel/SerializeSTL.h"
#include <ostream>

// Forward declarations

namespace DayaBay 
{

  // Forward declarations
  class RecRpcHeader;
  using GaudiUtils::operator<<;
  

  class RecRpcTrigger
  {
  public:

  RecRpcTrigger(const RecRpcTrigger& obj);
  
    RecRpcTrigger() : m_detector(0),
                      m_triggerNumber(0),
                      m_triggerTime(0),
                      m_triggerType(DayaBay::Trigger::kUnknown),
                      m_combinationType(0),
                      m_eventType(0),
                      m_clusters(),
                      m_tracks(),
                      m_header(0) {}
  
  virtual ~RecRpcTrigger();
  
   virtual std::ostream& fillStream(std::ostream& s) const;
  
    RecRpcTrigger& operator=(const RecRpcTrigger& obj);
  
    unsigned int combinationType() const;
  
    const DayaBay::RecRpcCluster* getCluster(int index) const;
  
    void addCluster(const DayaBay::RecRpcCluster* cluster);
  
    int numCluster() const;
  
    const DayaBay::RecRpcTrack& getTrack(int index) const;
  
    void addTrack(const DayaBay::RecRpcTrack& track);
  
    int numTrack() const;
  
    int maxHitsInLayer() const;
  
    bool is4of4() const;
  
  const DayaBay::Detector& detector() const;
  
  void setDetector(const DayaBay::Detector& value);
  
  unsigned int triggerNumber() const;
  
  void setTriggerNumber(unsigned int value);
  
  const TimeStamp& triggerTime() const;
  
  void setTriggerTime(const TimeStamp& value);
  
  const DayaBay::Trigger::TriggerType_t& triggerType() const;
  
  void setTriggerType(const DayaBay::Trigger::TriggerType_t& value);
  
  unsigned int eventType() const;
  
  void setEventType(unsigned int value);
  
  const std::vector<const DayaBay::RecRpcCluster*>& clusters() const;
  
  const std::vector<DayaBay::RecRpcTrack>& tracks() const;
  
  const DayaBay::RecRpcHeader* header() const;
  
  void setHeader(DayaBay::RecRpcHeader* value);
  
  
  #ifndef GOD_NOALLOC

    static void* operator new ( size_t size )
    {
      return ( sizeof(RecRpcTrigger) == size ? 
               boost::singleton_pool<RecRpcTrigger, sizeof(RecRpcTrigger)>::malloc() :
               ::operator new(size) );
    }
  
    static void* operator new ( size_t size, void* pObj )
    {
      return ::operator new (size,pObj);
    }
  
    static void operator delete ( void* p )
    {
      boost::singleton_pool<RecRpcTrigger, sizeof(RecRpcTrigger)>::is_from(p) ?
      boost::singleton_pool<RecRpcTrigger, sizeof(RecRpcTrigger)>::free(p) :
      ::operator delete(p);
    }
  
    static void operator delete ( void* p, void* pObj )
    {
      ::operator delete (p, pObj);
    }
  #endif
  protected:

  private:

    DayaBay::Detector                          m_detector;        
    unsigned int                               m_triggerNumber;   
    TimeStamp                                  m_triggerTime;     
    DayaBay::Trigger::TriggerType_t            m_triggerType;     
    unsigned int                               m_combinationType; 
    unsigned int                               m_eventType;       
    std::vector<const DayaBay::RecRpcCluster*> m_clusters;        
    std::vector<DayaBay::RecRpcTrack>          m_tracks;          
    DayaBay::RecRpcHeader*                     m_header;          
  
  }; // class RecRpcTrigger

  inline std::ostream& operator<< (std::ostream& str, const RecRpcTrigger& obj)
  {
    return obj.fillStream(str);
  }
  
} // namespace DayaBay;

// -----------------------------------------------------------------------------
// end of class
// -----------------------------------------------------------------------------

// Including forward declarations
#include "RecRpcHeader.h"


inline std::ostream& DayaBay::RecRpcTrigger::fillStream(std::ostream& s) const
{
  s << "{ " << "detector :      " << m_detector << std::endl
            << "triggerNumber : " << m_triggerNumber << std::endl
            << "triggerTime :   " << m_triggerTime << std::endl
            << "triggerType :   " << m_triggerType << std::endl
            << "combinationType :       " << m_combinationType << std::endl
            << "eventType :     " << m_eventType << std::endl
            << "clusters :      " << m_clusters << std::endl
            << "tracks :        " << m_tracks << std::endl
            << "header :        " << m_header << std::endl << " }";
  return s;
}


inline const DayaBay::Detector& DayaBay::RecRpcTrigger::detector() const 
{
  return m_detector;
}

inline void DayaBay::RecRpcTrigger::setDetector(const DayaBay::Detector& value) 
{
  m_detector = value;
}

inline unsigned int DayaBay::RecRpcTrigger::triggerNumber() const 
{
  return m_triggerNumber;
}

inline void DayaBay::RecRpcTrigger::setTriggerNumber(unsigned int value) 
{
  m_triggerNumber = value;
}

inline const TimeStamp& DayaBay::RecRpcTrigger::triggerTime() const 
{
  return m_triggerTime;
}

inline void DayaBay::RecRpcTrigger::setTriggerTime(const TimeStamp& value) 
{
  m_triggerTime = value;
}

inline const DayaBay::Trigger::TriggerType_t& DayaBay::RecRpcTrigger::triggerType() const 
{
  return m_triggerType;
}

inline void DayaBay::RecRpcTrigger::setTriggerType(const DayaBay::Trigger::TriggerType_t& value) 
{
  m_triggerType = value;
}

inline unsigned int DayaBay::RecRpcTrigger::eventType() const 
{
  return m_eventType;
}

inline void DayaBay::RecRpcTrigger::setEventType(unsigned int value) 
{
  m_eventType = value;
}

inline const std::vector<const DayaBay::RecRpcCluster*>& DayaBay::RecRpcTrigger::clusters() const 
{
  return m_clusters;
}

inline const std::vector<DayaBay::RecRpcTrack>& DayaBay::RecRpcTrigger::tracks() const 
{
  return m_tracks;
}

inline const DayaBay::RecRpcHeader* DayaBay::RecRpcTrigger::header() const 
{
  return m_header;
}

inline void DayaBay::RecRpcTrigger::setHeader(DayaBay::RecRpcHeader* value) 
{
  m_header = value;
}


#endif ///RecEvent_RecRpcTrigger_H