---

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 "Kernel/LHCbID.h"
#include "GaudiKernel/ObjectList.h"
#include "GaudiKernel/ObjectVector.h"
#include "CLHEP/Geometry/Plane3D.h"
#include "GaudiKernel/StreamBuffer.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,L1KShort,L1Downstream,HLTRZVelo,HLTSpaceVelo,HLTVeloTT};   
  enum HistoryFlag {LongTrack,Seeding,TrKshort,TrMatching,VeloTrack,VeloTT,TrgForward,TrgVelo,TrgVeloTT};   

  TrTrack() 
    : m_chi2PerDoF(0.0),
    m_nDoF(0),
    m_flags(0),
    m_lhcbids(),
    m_physicsState(),
    m_states() {}

  virtual ~TrTrack() {}

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

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

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

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

  double p() const;

  double pt() const;

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

  StatusCode posMomCovariance(HepSymMatrix& cov6D) const;

  int charge() const;

  unsigned int nStates() const;

  void addToStates(TrState* value);

  void removeFromStates(const TrState& value);

  virtual TrState* closestState(double z);

  virtual const TrState* closestState(double z) const;

  virtual TrState* closestState(HepPlane3D& plane);

  virtual const TrState* closestState(HepPlane3D& plane) const;

  double chi2() const;

  virtual void reset();

  virtual TrTrack* clone() const;

  std::vector<LHCbID> & LHCbIDs();

  const std::vector<LHCbID> & LHCbIDs() const;

  void setLHCbIDs(const std::vector<LHCbID>& value);

  void addToLHCbIDs(const LHCbID& value);

  void removeFromLHCbIDs(const LHCbID& value);

  bool type(unsigned value) const;

  void setType(unsigned value);

  bool history(unsigned value) const;

  void setHistory(unsigned value);

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

  bool flag(unsigned value) const;

  void setFlag(unsigned 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 TrState& physicsState() const; 

  TrState& physicsState();

  void setPhysicsState(const TrState& value);

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

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

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

  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}; 

  double                m_chi2PerDoF;   
  int                   m_nDoF;         
  unsigned              m_flags;        
  std::vector<LHCbID>   m_lhcbids;      
  TrState               m_physicsState; 
  std::vector<TrState*> m_states;       

};

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


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

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

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

inline void TrTrack::addToStates(TrState* value)
{
   
  m_states.push_back( value );
        
}

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

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;
  m_physicsState = 0;
  m_states.clear();
        
}

inline std::vector<LHCbID> & TrTrack::LHCbIDs()
{
   
  return m_lhcbids;
        
}

inline const std::vector<LHCbID> & TrTrack::LHCbIDs() const
{
   
  return m_lhcbids;
        
}

inline void TrTrack::setLHCbIDs(const std::vector<LHCbID>& value)
{
   
  m_lhcbids = value;
        
}

inline void TrTrack::addToLHCbIDs(const LHCbID& value)
{
   
  m_lhcbids.push_back( value );
        
}

inline void TrTrack::removeFromLHCbIDs(const LHCbID& value)
{
   
  std::vector<LHCbID>::iterator iter =
    std::remove( m_lhcbids.begin(), m_lhcbids.end(), value );
  m_lhcbids.erase( iter, m_lhcbids.end() );
        
}

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 TrState& TrTrack::physicsState() const 
{
  return m_physicsState;
}

inline TrState& TrTrack::physicsState()
{
  return m_physicsState;
}

inline void TrTrack::setPhysicsState(const TrState& value)
{
  m_physicsState = value; 
}

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

inline std::vector<TrState*>& TrTrack::states()
{
  return m_states;
}

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

inline StreamBuffer& TrTrack::serialize(StreamBuffer& s) const 
{
  KeyedObject<int>::serialize(s);
  s << (float)m_chi2PerDoF
    << m_nDoF
    << m_flags
    << m_physicsState;
  return s;
}

inline StreamBuffer& TrTrack::serialize(StreamBuffer& s)
{
  float l_chi2PerDoF;
  KeyedObject<int>::serialize(s);
  s >> l_chi2PerDoF
    >> m_nDoF
    >> m_flags
    >> m_physicsState;
  m_chi2PerDoF = l_chi2PerDoF;
  return s;
}

inline std::ostream& TrTrack::fillStream(std::ostream& s) const
{
  s << "{ "
    << " chi2PerDoF:\t" << (float)m_chi2PerDoF << std::endl
    << "   nDoF:\t" << m_nDoF << std::endl
    << "   flags:\t" << m_flags << std::endl
    << "   valid:\t" << valid() << std::endl
    << "   lhcbids:\t" << m_lhcbids << std::endl
    << "   physicsState:\t" << m_physicsState << std::endl
    << "   states:\t" << m_states << " } ";
  return s;
}

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

#endif   

---