SimVertex.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 SimEvent_SimVertex_H
#define SimEvent_SimVertex_H 1

// Include files
#include "Event/SimTrackReference.h"
#include "Event/SimVertexReference.h"
#include "Event/SimProcess.h"
#include "GaudiKernel/Point3DTypes.h"
#include "GaudiKernel/Vector3DTypes.h"
#include "GaudiKernel/boost_allocator.h"
#include <vector>
#include <list>
#include <map>
#include <ostream>

// Forward declarations

namespace DayaBay 
{

  // Forward declarations

  class SimVertex
  {
  public:

  SimVertex() : m_track(),
                 m_process(),
                 m_time(-1e18),
                 m_position(),
                 m_totalEnergy(0),
                 m_momentum(),
                 m_secondaries(0) {}
  
  SimVertex(const SimTrackReference& track,
              const SimProcess& process,
              double time,
              const Gaudi::XYZPoint& position,
              double totEnergy,
              const Gaudi::XYZVector& momentum) : m_track(track),
                                                 m_process(process),
                                                 m_time(time),
                                                 m_position(position),
                                                 m_totalEnergy(totEnergy),
                                                 m_momentum(momentum),
                                                 m_secondaries(0) {}
  
    virtual ~SimVertex() {}
  
    double mass() const;
  
    double kineticEnergy() const;
  
    void addSecondary(const SimTrackReference& ref);
  
    std::ostream& fillStream(std::ostream& s) const;
  
  const DayaBay::SimTrackReference& track() const;
  
  void setTrack(const DayaBay::SimTrackReference& value);
  
  const DayaBay::SimProcess& process() const;
  
  void setProcess(const DayaBay::SimProcess& value);
  
  double time() const;
  
  void setTime(double value);
  
  const Gaudi::XYZPoint& position() const;
  
  void setPosition(const Gaudi::XYZPoint& value);
  
  double totalEnergy() const;
  
  void setTotalEnergy(double value);
  
  const Gaudi::XYZVector& momentum() const;
  
  void setMomentum(const Gaudi::XYZVector& value);
  
  const std::vector<DayaBay::SimTrackReference>& secondaries() const;
  
  void setSecondaries(const std::vector<DayaBay::SimTrackReference>& value);
  
  
  #ifndef GOD_NOALLOC

    static void* operator new ( size_t size )
    {
      return ( sizeof(SimVertex) == size ? 
               boost::singleton_pool<SimVertex, sizeof(SimVertex)>::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<SimVertex, sizeof(SimVertex)>::is_from(p) ?
      boost::singleton_pool<SimVertex, sizeof(SimVertex)>::free(p) :
      ::operator delete(p);
    }
  
    static void operator delete ( void* p, void* pObj )
    {
      ::operator delete (p, pObj);
    }
  #endif
  protected:

  private:

    DayaBay::SimTrackReference              m_track;       
    DayaBay::SimProcess                     m_process;     
    double                                  m_time;        
    Gaudi::XYZPoint                         m_position;    
    double                                  m_totalEnergy; 
    Gaudi::XYZVector                        m_momentum;    
    std::vector<DayaBay::SimTrackReference> m_secondaries; 
  
  }; // class SimVertex

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

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

// Including forward declarations

inline const DayaBay::SimTrackReference& DayaBay::SimVertex::track() const 
{
  return m_track;
}

inline void DayaBay::SimVertex::setTrack(const DayaBay::SimTrackReference& value) 
{
  m_track = value;
}

inline const DayaBay::SimProcess& DayaBay::SimVertex::process() const 
{
  return m_process;
}

inline void DayaBay::SimVertex::setProcess(const DayaBay::SimProcess& value) 
{
  m_process = value;
}

inline double DayaBay::SimVertex::time() const 
{
  return m_time;
}

inline void DayaBay::SimVertex::setTime(double value) 
{
  m_time = value;
}

inline const Gaudi::XYZPoint& DayaBay::SimVertex::position() const 
{
  return m_position;
}

inline void DayaBay::SimVertex::setPosition(const Gaudi::XYZPoint& value) 
{
  m_position = value;
}

inline double DayaBay::SimVertex::totalEnergy() const 
{
  return m_totalEnergy;
}

inline void DayaBay::SimVertex::setTotalEnergy(double value) 
{
  m_totalEnergy = value;
}

inline const Gaudi::XYZVector& DayaBay::SimVertex::momentum() const 
{
  return m_momentum;
}

inline void DayaBay::SimVertex::setMomentum(const Gaudi::XYZVector& value) 
{
  m_momentum = value;
}

inline const std::vector<DayaBay::SimTrackReference>& DayaBay::SimVertex::secondaries() const 
{
  return m_secondaries;
}

inline void DayaBay::SimVertex::setSecondaries(const std::vector<DayaBay::SimTrackReference>& value) 
{
  m_secondaries = value;
}

inline void DayaBay::SimVertex::addSecondary(const SimTrackReference& ref) 
{

    m_secondaries.push_back(ref);
        
}


#endif ///SimEvent_SimVertex_H