---

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 <algorithm>
#include "Kernel/CLHEPStreams.h"
#include "TrKernel/ITrExtrapolator.h"
#include "GaudiKernel/KeyedObject.h"
#include "Kernel/LHCbID.h"
#include "GaudiKernel/ObjectList.h"
#include "GaudiKernel/ObjectVector.h"
#include "Kernel/ParticleID.h"
#include "CLHEP/Geometry/Plane3D.h"
#include "GaudiKernel/SmartRef.h"
#include "GaudiKernel/SmartRefVector.h"
#include "GaudiKernel/StreamBuffer.h"
#include "Event/TrNode.h"
#include "Event/TrState.h"


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

// Namespace for locations in TDS
namespace TrTrackLocation {
  static const std::string& Default = "Rec/Tr/Best";
  static const std::string& Velo = "Rec/Tr/Velo";
  static const std::string& Seed = "Rec/Tr/Seed";
  static const std::string& Match = "Rec/Tr/Match";
  static const std::string& Forward = "Rec/Tr/Forward";
  static const std::string& Follow = "Rec/Tr/Follow";
  static const std::string& VeloTT = "Rec/Tr/VeloTT";
  static const std::string& KsTrack = "Rec/Tr/KsTrack";
}


class TrTrack: public KeyedObject<int>
{

public: 

  enum TrackType {Long,Velotrack,Backward,Ttrack,Upstream,Downstream,L1Long,L1RZVelo,L1SpaceVelo,L1VeloTT,L1MuonMatched,L1Tracks,L1KShort,L1Downstream,HLTLong,HLTRZVelo,HLTSpaceVelo,HLTVeloTT};   
  enum HistoryFlag {LongTrack,Seeding,TrKshort,TrMatching,VeloTrack,VeloTT,TrgForward,TrgVelo,TrgVeloTT};   

  TrTrack(const TrTrack& track);

  TrTrack() 
    : m_type(0),
    m_chi2PerDoF(0.0),
    m_nDoF(0),
    m_historyFlag(0),
    m_flags(0) {}

  virtual ~TrTrack() {}

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

  StatusCode positionAndMomentum(HepPoint3D& pos, HepVector3D& mom, HepSymMatrix& cov6D);

  StatusCode positionAndMomentum(double z, ITrExtrapolator* extrapolator, ParticleID& pid, HepPoint3D& pos, HepVector3D& mom, HepSymMatrix& cov6D);

  StatusCode positionAndMomentum(HepPlane3D& plane, ITrExtrapolator* extrapolator, ParticleID& pid, HepPoint3D& pos, HepVector3D& mom, HepSymMatrix& cov6D);

  StatusCode position(HepPoint3D& pos, HepSymMatrix& errPos);

  StatusCode position(double z, ITrExtrapolator* extrapolator, ParticleID& pid, HepPoint3D& pos, HepSymMatrix& errPos);

  StatusCode position(HepPlane3D& plane, ITrExtrapolator* extrapolator, ParticleID& pid, HepPoint3D& pos, HepSymMatrix& errPos);

  StatusCode slopes(HepVector3D& slopes, HepSymMatrix& errSlopes);

  StatusCode slopes(double z, ITrExtrapolator* extrapolator, ParticleID& pid, HepVector3D& slopes, HepSymMatrix& errSlopes);

  StatusCode slopes(HepPlane3D& plane, ITrExtrapolator* extrapolator, ParticleID& pid, HepVector3D& slopes, HepSymMatrix& errSlopes);

  double p();

  StatusCode p(double z, ITrExtrapolator* extrapolator, ParticleID& pid, double p);

  StatusCode p(HepPlane3D& plane, ITrExtrapolator* extrapolator, ParticleID& pid, double p);

  double pt();

  StatusCode pt(double z, ITrExtrapolator* extrapolator, ParticleID& pid, double pt);

  StatusCode pt(HepPlane3D& plane, ITrExtrapolator* extrapolator, ParticleID& pid, double pt);

  StatusCode momentum(HepVector3D& mom, HepSymMatrix& errMom);

  StatusCode momentum(double z, ITrExtrapolator* extrapolator, ParticleID& pid, HepVector3D& mom, HepSymMatrix& errMom);

  StatusCode momentum(HepPlane3D& plane, ITrExtrapolator* extrapolator, ParticleID& pid, HepVector3D& mom, HepSymMatrix& errMom);

  StatusCode posMomCovariance(HepSymMatrix& cov6D);

  StatusCode posMomCovariance(double z, ITrExtrapolator* extrapolator, ParticleID& pid, HepSymMatrix& cov6D);

  StatusCode posMomCovariance(HepPlane3D& plane, ITrExtrapolator* extrapolator, ParticleID& pid, HepSymMatrix& cov6D);

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

  int charge() const;

  unsigned int nStates() const;

  virtual TrState* closestState(double z);

  virtual TrState* closestState(HepPlane3D& plane);

  double chi2() const;

  virtual void reset();

  virtual TrTrack* clone();

  int type() const; 

  void setType(int value);

  double chi2PerDoF() const; 

  void setChi2PerDoF(double value);

  int nDoF() const; 

  void setNDoF(int value);

  unsigned flags() const; 

  void setFlags(unsigned value);

  void setValid(bool value);

  bool valid() const;

  const SmartRefVector<LHCbID>& lhcbIDs() const;

  SmartRefVector<LHCbID>& lhcbIDs();

  void setLhcbIDs(const SmartRefVector<LHCbID>& value);

  void addToLhcbIDs(const SmartRef<LHCbID>& value); 

  void removeFromLhcbIDs(const SmartRef<LHCbID>& value); 

  void clearLhcbIDs();

  const TrState* closestState() const;

  TrState* closestState();

  void setClosestState(const SmartRef<TrState>& value);

  const SmartRefVector<TrState>& states() const;

  SmartRefVector<TrState>& states();

  void setStates(const SmartRefVector<TrState>& value);

  void addToStates(const SmartRef<TrState>& value); 

  void removeFromStates(const SmartRef<TrState>& value); 

  void clearStates();

  virtual StreamBuffer& serialize(StreamBuffer& s) const;

  virtual StreamBuffer& serialize(StreamBuffer& s);

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

protected: 

private: 

  enum flagsBits {validBits = 0}; 
  enum flagsMasks {validMask = 0x00000001}; 

  int                     m_type;         
  double                  m_chi2PerDoF;   
  int                     m_nDoF;         
  int                     m_historyFlag;  
  unsigned                m_flags;        
  SmartRefVector<LHCbID>  m_lhcbIDs;      
  SmartRef<TrState>       m_closestState; 
  SmartRefVector<TrState> m_states;       

};

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


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

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

inline int TrTrack::charge() const
{
   
  return ( ( m_closestState->qOverP() > 0. ) ? 1 : -1 );
        
}

inline unsigned int TrTrack::nStates() const
{
   
  return m_states.size();
        
}

inline double TrTrack::chi2() const
{
   
  return ( m_chi2PerDoF * double(m_nDoF) );
        
}

inline void TrTrack::reset()
{
   
  m_type         = 0;
  m_chi2PerDoF   = 0;
  m_nDoF         = 0;
  m_historyFlag  = 0;

}

inline int TrTrack::type() const 
{
  return m_type;
}

inline void TrTrack::setType(int value)
{
  m_type = value; 
}

inline double TrTrack::chi2PerDoF() const 
{
  return m_chi2PerDoF;
}

inline void TrTrack::setChi2PerDoF(double value)
{
  m_chi2PerDoF = value; 
}

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

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

inline unsigned TrTrack::flags() const 
{
  return m_flags;
}

inline void TrTrack::setFlags(unsigned value)
{
  m_flags = value; 
}

inline void TrTrack::setValid(bool value)
{
  unsigned val  = (unsigned)value;
  m_flags &= ~validMask;
  m_flags |= ((((unsigned)val) << validBits) & validMask);
}

inline bool TrTrack::valid() const
{
  return (bool)((m_flags & validMask) >> validBits);
}

inline const SmartRefVector<LHCbID>& TrTrack::lhcbIDs() const
{
   return m_lhcbIDs;
}

inline SmartRefVector<LHCbID>& TrTrack::lhcbIDs()
{
   return m_lhcbIDs;
}

inline void TrTrack::setLhcbIDs(const SmartRefVector<LHCbID>& value)
{
   m_lhcbIDs = value;
}

inline void TrTrack::addToLhcbIDs(const SmartRef<LHCbID>& value)
{
   m_lhcbIDs.push_back(value);
}

inline void TrTrack::removeFromLhcbIDs(const SmartRef<LHCbID>& value)
{
  SmartRefVector<LHCbID>::iterator iter =
    std::remove(m_lhcbIDs.begin(), m_lhcbIDs.end(), value);
  m_lhcbIDs.erase(iter, m_lhcbIDs.end());
}

inline void TrTrack::clearLhcbIDs()
{
   m_lhcbIDs.clear();
}

inline const TrState* TrTrack::closestState() const
{
   return m_closestState;
}

inline TrState* TrTrack::closestState() 
{
   return m_closestState;
}

inline void TrTrack::setClosestState(const SmartRef<TrState>& value)
{
   m_closestState = value;
}

inline const SmartRefVector<TrState>& TrTrack::states() const
{
   return m_states;
}

inline SmartRefVector<TrState>& TrTrack::states()
{
   return m_states;
}

inline void TrTrack::setStates(const SmartRefVector<TrState>& value)
{
   m_states = value;
}

inline void TrTrack::addToStates(const SmartRef<TrState>& value)
{
   m_states.push_back(value);
}

inline void TrTrack::removeFromStates(const SmartRef<TrState>& value)
{
  SmartRefVector<TrState>::iterator iter =
    std::remove(m_states.begin(), m_states.end(), value);
  m_states.erase(iter, m_states.end());
}

inline void TrTrack::clearStates()
{
   m_states.clear();
}

inline StreamBuffer& TrTrack::serialize(StreamBuffer& s) const 
{
  KeyedObject<int>::serialize(s);
  s << m_type
    << (float)m_chi2PerDoF
    << m_nDoF
    << m_historyFlag
    << m_flags
    << m_lhcbIDs(this)
    << m_closestState(this);
  return s;
}

inline StreamBuffer& TrTrack::serialize(StreamBuffer& s)
{
  float l_chi2PerDoF;
  KeyedObject<int>::serialize(s);
  s >> m_type
    >> l_chi2PerDoF
    >> m_nDoF
    >> m_historyFlag
    >> m_flags
    >> m_lhcbIDs(this)
    >> m_closestState(this);
  m_chi2PerDoF = l_chi2PerDoF;
  return s;
}

inline std::ostream& TrTrack::fillStream(std::ostream& s) const
{
  s << "{ "
    << " type:\t" << m_type << std::endl
    << "   chi2PerDoF:\t" << (float)m_chi2PerDoF << std::endl
    << "   nDoF:\t" << m_nDoF << std::endl
    << "   historyFlag:\t" << m_historyFlag << std::endl
    << "   flags:\t" << m_flags << std::endl
    << "   valid:\t" << valid() << " } ";
  return s;
}

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

#endif   

---