TrackVertex.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 TackEvent_TrackVertex_H
#define TackEvent_TrackVertex_H 1

// Include files
#include "Event/Track.h"
#include "CLHEP/Units/SystemOfUnits.h"
#include "GaudiKernel/KeyedObject.h"
#include "GaudiKernel/KeyedContainer.h"
#include "CLHEP/Geometry/Point3D.h"
#include "CLHEP/Matrix/SymMatrix.h"
#include "GaudiKernel/SmartRefVector.h"
#include <ostream>


// Forward declarations

// Class ID definition
static const CLID& CLID_TrackVertex = 10020;

// Namespace for locations in TDS
namespace TrackVertexLocation {
  static const std::string& Velo2D = "Rec/Trig/Vertex2D";
  static const std::string& Velo3D = "Rec/Trig/Vertex3D";
}


class TrackVertex: public KeyedObject<int>
{
public:

  TrackVertex(int key) : KeyedObject<int>( key ),
                        m_position(0.0,
                         0.0,
                         -1*km),
                         m_positionErr(3,
                         0) {}

  TrackVertex() : m_position(0.0, 0.0, -1*km),
                  m_positionErr(3, 0),
                  m_chi2(0.0),
                  m_nDoF(0) {}

  virtual ~TrackVertex() {}

  // Retrieve pointer to class definition structure
  virtual const CLID& clID() const;
  static const CLID& classID();

  friend std::ostream& operator<< (std::ostream& str,
                                   const TrackVertex& obj);

  virtual std::ostream& fillStream(std::ostream& s) const;

  const HepPoint3D& position() const;

  HepPoint3D& position();

  void setPosition(const HepPoint3D& value);

  const HepSymMatrix& positionErr() const;

  HepSymMatrix& positionErr();

  void setPositionErr(const HepSymMatrix& value);

  double chi2() const;

  void setChi2(double value);

  int nDoF() const;

  void setNDoF(int value);

  const SmartRefVector<Track>& tracks() const;

  SmartRefVector<Track>& tracks();

  void setTracks(const SmartRefVector<Track>& value);

  void addToTracks(const SmartRef<Track>& value);

  void addToTracks(const Track* value);

  void removeFromTracks(const SmartRef<Track>& value);

  void clearTracks();

protected:

private:

  HepPoint3D            m_position;    
  HepSymMatrix          m_positionErr; 
  double                m_chi2;        
  int                   m_nDoF;        
  SmartRefVector<Track> m_tracks;      

};

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

// Including forward declarations

inline const CLID& TrackVertex::clID() const
{
  return TrackVertex::classID();
}

inline const CLID& TrackVertex::classID()
{
  return CLID_TrackVertex;
}

inline std::ostream& operator<< (std::ostream& str,
                                 const TrackVertex& obj)
{
  return obj.fillStream(str);
}

inline std::ostream& TrackVertex::fillStream(std::ostream& s) const
{
  s << "{ " << "position :      " << m_position << std::endl
            << "positionErr :   " << m_positionErr << std::endl
            << "chi2 :  " << (float)m_chi2 << std::endl
            << "nDoF :  " << m_nDoF << std::endl << " }";
  return s;
}


inline const HepPoint3D& TrackVertex::position() const 
{
  return m_position;
}

inline HepPoint3D& TrackVertex::position() 
{
  return m_position;
}

inline void TrackVertex::setPosition(const HepPoint3D& value) 
{
  m_position = value;
}

inline const HepSymMatrix& TrackVertex::positionErr() const 
{
  return m_positionErr;
}

inline HepSymMatrix& TrackVertex::positionErr() 
{
  return m_positionErr;
}

inline void TrackVertex::setPositionErr(const HepSymMatrix& value) 
{
  m_positionErr = value;
}

inline double TrackVertex::chi2() const 
{
  return m_chi2;
}

inline void TrackVertex::setChi2(double value) 
{
  m_chi2 = value;
}

inline int TrackVertex::nDoF() const 
{
  return m_nDoF;
}

inline void TrackVertex::setNDoF(int value) 
{
  m_nDoF = value;
}

inline const SmartRefVector<Track>& TrackVertex::tracks() const 
{
  return m_tracks;
}

inline SmartRefVector<Track>& TrackVertex::tracks() 
{
  return m_tracks;
}

inline void TrackVertex::setTracks(const SmartRefVector<Track>& value) 
{
  m_tracks = value;
}

inline void TrackVertex::addToTracks(const SmartRef<Track>& value) 
{
  m_tracks.push_back(value);
}

inline void TrackVertex::addToTracks(const Track* value) 
{
  m_tracks.push_back(value);
}

inline void TrackVertex::removeFromTracks(const SmartRef<Track>& value) 
{
  SmartRefVector<Track>::iterator iter =
    std::remove(m_tracks.begin(), m_tracks.end(), value);
  m_tracks.erase(iter, m_tracks.end());
}

inline void TrackVertex::clearTracks() 
{
  m_tracks.clear();
}

// Definition of Keyed Container for TrackVertex
typedef KeyedContainer<TrackVertex, Containers::HashMap> TrackVertices;



#endif 

---