In This Package:

RecTrigger.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_RecTrigger_H
#define RecEvent_RecTrigger_H 1

// Include files
#include "Context/TimeStamp.h"
#include "Conventions/Detectors.h"
#include "Conventions/Electronics.h"
#include "Conventions/Trigger.h"
#include "CLHEP/Vector/LorentzVector.h"
#include "CLHEP/Matrix/Matrix.h"
#include "GaudiKernel/boost_allocator.h"
#include <ostream>

// Forward declarations

namespace DayaBay 
{

  // Forward declarations
  class RecHeader;
  

  class RecTrigger
  {
  public:

    RecTrigger() : m_detector(0),
                   m_triggerNumber(0),
                   m_triggerTime(0),
                   m_triggerType(),
                   m_energy(0),
                   m_position(),
                   m_direction(),
                   m_energyStatus(0),
                   m_positionStatus(0),
                   m_directionStatus(0),
                   m_energyQuality(0),
                   m_positionQuality(0),
                   m_directionQuality(0),
                   m_errorMatrix(),
                   m_header(0) {}
  
    RecTrigger(const RecTrigger & rh);
  
     RecTrigger & operator=(const RecTrigger & rh);
  
    virtual ~RecTrigger() {}
  
   virtual std::ostream& fillStream(std::ostream& s) 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);
  
  double energy() const;
  
  void setEnergy(double value);
  
  const CLHEP::HepLorentzVector& position() const;
  
  void setPosition(const CLHEP::HepLorentzVector& value);
  
  const CLHEP::HepLorentzVector& direction() const;
  
  void setDirection(const CLHEP::HepLorentzVector& value);
  
  int energyStatus() const;
  
  void setEnergyStatus(int value);
  
  int positionStatus() const;
  
  void setPositionStatus(int value);
  
  int directionStatus() const;
  
  void setDirectionStatus(int value);
  
  double energyQuality() const;
  
  void setEnergyQuality(double value);
  
  double positionQuality() const;
  
  void setPositionQuality(double value);
  
  double directionQuality() const;
  
  void setDirectionQuality(double value);
  
  const CLHEP::HepMatrix& errorMatrix() const;
  
  void setErrorMatrix(const CLHEP::HepMatrix& value);
  
  const DayaBay::RecHeader* header() const;
  
  void setHeader(DayaBay::RecHeader* value);
  
  
  #ifndef GOD_NOALLOC
    static void* operator new ( size_t size )
    {
      return ( sizeof(RecTrigger) == size ? 
               boost::singleton_pool<RecTrigger, sizeof(RecTrigger)>::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<RecTrigger, sizeof(RecTrigger)>::is_from(p) ?
      boost::singleton_pool<RecTrigger, sizeof(RecTrigger)>::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;      
    double                          m_energy;           
    CLHEP::HepLorentzVector         m_position;         
    CLHEP::HepLorentzVector         m_direction;        
    int                             m_energyStatus;     
    int                             m_positionStatus;   
    int                             m_directionStatus;  
    double                          m_energyQuality;    
    double                          m_positionQuality;  
    double                          m_directionQuality; 
    CLHEP::HepMatrix                m_errorMatrix;      
    DayaBay::RecHeader*             m_header;           
  
  }; // class RecTrigger

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

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

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


inline DayaBay::RecTrigger::RecTrigger(const DayaBay::RecTrigger & rh) : 
   m_detector( rh.m_detector ),
   m_triggerNumber( rh.m_triggerNumber ),
   m_triggerTime( rh.m_triggerTime ),
   m_triggerType( rh.m_triggerType ),
   m_energy( rh.m_energy ),
   m_position( rh.m_position ),
   m_direction( rh.m_direction ),
   m_energyStatus( rh.m_energyStatus ),
   m_positionStatus( rh.m_positionStatus ),
   m_directionStatus( rh.m_directionStatus ),
   m_energyQuality( rh.m_energyQuality ),
   m_positionQuality( rh.m_positionQuality ),
   m_directionQuality( rh.m_directionQuality ),
   m_errorMatrix( rh.m_errorMatrix ),
   m_header( rh.m_header )
   {}

inline DayaBay::RecTrigger & DayaBay::RecTrigger::operator=(const DayaBay::RecTrigger & rh) {
  if ( this != &rh ) {
    m_detector         = rh.m_detector;
    m_triggerNumber    = rh.m_triggerNumber;
    m_triggerTime      = rh.m_triggerTime;
    m_triggerType      = rh.m_triggerType;
    m_energy           = rh.m_energy;
    m_position         = rh.m_position;
    m_direction        = rh.m_direction;
    m_energyStatus     = rh.m_energyStatus;
    m_positionStatus   = rh.m_positionStatus;
    m_directionStatus  = rh.m_directionStatus;
    m_energyQuality    = rh.m_energyQuality;
    m_positionQuality  = rh.m_positionQuality;
    m_directionQuality = rh.m_directionQuality;
    m_errorMatrix      = rh.m_errorMatrix;
    m_header           = rh.m_header;
  }
  return *this;
}

inline std::ostream& DayaBay::RecTrigger::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
            << "energy :        " << (float)m_energy << std::endl
            << "position :      " << m_position << std::endl
            << "direction :     " << m_direction << std::endl
            << "energyStatus :  " << m_energyStatus << std::endl
            << "positionStatus :        " << m_positionStatus << std::endl
            << "directionStatus :       " << m_directionStatus << std::endl
            << "energyQuality : " << (float)m_energyQuality << std::endl
            << "positionQuality :       " << (float)m_positionQuality << std::endl
            << "directionQuality :      " << (float)m_directionQuality << std::endl
            << "errorMatrix :   " << m_errorMatrix << std::endl
            << "header :        " << m_header << std::endl << " }";
  return s;
}


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

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

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

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

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

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

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

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

inline double DayaBay::RecTrigger::energy() const 
{
  return m_energy;
}

inline void DayaBay::RecTrigger::setEnergy(double value) 
{
  m_energy = value;
}

inline const CLHEP::HepLorentzVector& DayaBay::RecTrigger::position() const 
{
  return m_position;
}

inline void DayaBay::RecTrigger::setPosition(const CLHEP::HepLorentzVector& value) 
{
  m_position = value;
}

inline const CLHEP::HepLorentzVector& DayaBay::RecTrigger::direction() const 
{
  return m_direction;
}

inline void DayaBay::RecTrigger::setDirection(const CLHEP::HepLorentzVector& value) 
{
  m_direction = value;
}

inline int DayaBay::RecTrigger::energyStatus() const 
{
  return m_energyStatus;
}

inline void DayaBay::RecTrigger::setEnergyStatus(int value) 
{
  m_energyStatus = value;
}

inline int DayaBay::RecTrigger::positionStatus() const 
{
  return m_positionStatus;
}

inline void DayaBay::RecTrigger::setPositionStatus(int value) 
{
  m_positionStatus = value;
}

inline int DayaBay::RecTrigger::directionStatus() const 
{
  return m_directionStatus;
}

inline void DayaBay::RecTrigger::setDirectionStatus(int value) 
{
  m_directionStatus = value;
}

inline double DayaBay::RecTrigger::energyQuality() const 
{
  return m_energyQuality;
}

inline void DayaBay::RecTrigger::setEnergyQuality(double value) 
{
  m_energyQuality = value;
}

inline double DayaBay::RecTrigger::positionQuality() const 
{
  return m_positionQuality;
}

inline void DayaBay::RecTrigger::setPositionQuality(double value) 
{
  m_positionQuality = value;
}

inline double DayaBay::RecTrigger::directionQuality() const 
{
  return m_directionQuality;
}

inline void DayaBay::RecTrigger::setDirectionQuality(double value) 
{
  m_directionQuality = value;
}

inline const CLHEP::HepMatrix& DayaBay::RecTrigger::errorMatrix() const 
{
  return m_errorMatrix;
}

inline void DayaBay::RecTrigger::setErrorMatrix(const CLHEP::HepMatrix& value) 
{
  m_errorMatrix = value;
}

inline const DayaBay::RecHeader* DayaBay::RecTrigger::header() const 
{
  return m_header;
}

inline void DayaBay::RecTrigger::setHeader(DayaBay::RecHeader* value) 
{
  m_header = value;
}


#endif 

---