---

TrTrack.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 TrEvent_TrTrack_H
#define TrEvent_TrTrack_H 1

// Include files
#include <vector>
#include "Kernel/CLHEPStreams.h"
#include "GaudiKernel/KeyedObject.h"
#include "GaudiKernel/ObjectList.h"
#include "GaudiKernel/ObjectVector.h"
#include "GaudiKernel/StreamBuffer.h"
#include "Event/TrMeasurement.h"
#include "Event/TrState.h"


// Class ID definition
  static const CLID& CLID_TrTrack = 10003;

class TrTrack: public KeyedObject<int>
{

public: 

  enum TrackType {Velotrack,Backward,Long,Upstream,Downstream,Ttrack};   
  enum HistoryFlag {LongTrack,Seeding,TrKshort,TrMatching,VeloTrack,VeloTT};   

  TrTrack(const TrTrack& track);

  TrTrack() 
    : m_states(),
    m_measurements(),
    m_chi2(0.0),
    m_ndof(0),
    m_charge(0.0),
    m_errorFlag(0),
    m_type(0) {}

  virtual ~TrTrack() {}

  virtual const CLID& clID() const; 
  static const CLID& classID(); 

  void positionAndMomentum(const double z, const HepPoint3D& pos, const HepVector3D& mom, const HepSymMatrix& cov6D) const;

  HepPoint3D position(const double z) const;

  HepVector3D slopes(const double z) const;

  HepSymMatrix posMomCovariance(const double z) const;

  std::vector errPosition(const double z) const;

  std::vector errSlopes(const double z) const;

  double p(const double z) const;

  double pt(const double z) const;

  HepVector3D momentum(const double z) const;

  std::vector errMomentum(const double z) const;

  TrackType type();

  bool producedByAlgo(const TrTrack::HistoryFlag& flag);

  double chi2PerDoF() const;

  double chi2() const;

  void setChi2(double value);

  unsigned int nDoF() const;

  void setNDoF(unsigned int value);

  int errorFlag() const;

  void setErrorFlag(int value);

  void reset();

  void clone(TrTrack* track);

  double charge() const; 

  void setCharge(double value);

  virtual StreamBuffer& serialize(StreamBuffer& s) const;

  virtual StreamBuffer& serialize(StreamBuffer& s);

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

protected: 

  void setType(const TrTrack::TrackType& value);

  unsigned int nStates() const;

  TrState* closestState(double z) const;

  const std::vector<TrState*> states() const;

  void setStates(const const& std::vector<TrState*>);

  unsigned int nMeasurements() const;

  const std::vector<TrMeasurement*> measurements() const;

  void setMeasurements(const const& std::vector<TrState*>);

private: 

  std::vector<TrState*>       m_states;       
  std::vector<TrMeasurement*> m_measurements; 
  double                      m_chi2;         
  int                         m_ndof;         
  double                      m_charge;       
  int                         m_errorFlag;    
  int                         m_type;         

};

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


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

inline const CLID& TrTrack::classID()
{
  return CLID_TrTrack;
}

inline double TrTrack::chi2PerDoF() const
{
   
          return ( ( m_ndof > 0 ) ? m_chi2/double(m_ndof) : 0. );
        
}

inline void TrTrack::reset()
{
   
          m_closestState.reset();
          m_states.clear();
          m_measurements.clear();
          m_chi2      = 0;
          m_ndof      = 0;
          m_charge    = 0;
          m_errorFlag = 0;
        
}

inline double TrTrack::charge() const 
{
  return m_charge;
}

inline void TrTrack::setCharge(double value)
{
  m_charge = value; 
}

inline StreamBuffer& TrTrack::serialize(StreamBuffer& s) const 
{
  KeyedObject<int>::serialize(s);
  s << m_states
    << m_measurements
    << (float)m_chi2
    << m_ndof
    << (float)m_charge
    << m_errorFlag
    << m_type;
  return s;
}

inline StreamBuffer& TrTrack::serialize(StreamBuffer& s)
{
  float l_chi2, l_charge;
  KeyedObject<int>::serialize(s);
  s >> m_states
    >> m_measurements
    >> l_chi2
    >> m_ndof
    >> l_charge
    >> m_errorFlag
    >> m_type;
  m_chi2 = l_chi2;
  m_charge = l_charge;
  return s;
}

inline std::ostream& TrTrack::fillStream(std::ostream& s) const
{
  s << "{ "
    << " states:\t" << m_states << std::endl
    << "   measurements:\t" << m_measurements << std::endl
    << "   chi2:\t" << (float)m_chi2 << std::endl
    << "   ndof:\t" << m_ndof << std::endl
    << "   charge:\t" << (float)m_charge << std::endl
    << "   errorFlag:\t" << m_errorFlag << std::endl
    << "   type:\t" << m_type << " } ";
  return s;
}

//Definition of keyed container for TrTrack
typedef KeyedContainer<TrTrack, Containers::HashMap> TrTracks;

#endif   

---