Track.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 TrackEvent_Track_H
#define TrackEvent_Track_H 1

// Include files
#include "Event/State.h"
#include "Kernel/LHCbID.h"
#include "CLHEP/Geometry/Plane3D.h"
#include "GaudiKernel/KeyedObject.h"
#include "GaudiKernel/KeyedContainer.h"
#include <vector>


// Forward declarations
class StatusCode;
class Point3D;
class Vector3D;
class SymMatrix;


// Class ID definition
static const CLID& CLID_Track = 10010;

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


class Track: public KeyedObject<int>
{
public:

  enum TrackType{ Velo=1,
                  VeloR=2,
                  Backward=4,
                  Long=8,
                  Upstream=16,
                  Downstream=32,
                  Ttrack=64 };
  enum HistoryFlag{ LongTrack=1,
                    Seeding=2,
                    TrKshort=4,
                    TrMatching=8,
                    VeloTrack=16,
                    VeloTT=32,
                    TrgForward=64,
                    TrgVelo=128,
                    TrgVeloTT=256 };
  enum Flag{ Valid=1,
             Unique=2,
             IPSelected=4,
             MuSelected=8 };

  Track(int key) : KeyedObject<int>( key ),
                   m_chi2PerDoF(0.0),
                   m_nDoF(0),
                   m_flags(0),
                   m_lhcbIDs(),
                   m_physicsState(),
                   m_states() {}

  Track() : m_chi2PerDoF(0.0),
            m_nDoF(0),
            m_flags(0),
            m_lhcbIDs(),
            m_physicsState(),
            m_states() {}

  ~Track();

  // Retrieve pointer to class definition structure
  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;

  virtual unsigned int nMeasurements() const;

  unsigned int nStates() const;

  void addToStates(State* value);

  void removeFromStates(State* value);

  virtual State & closestState(double z);

  virtual const State & closestState(double z) const;

  virtual State & closestState(const HepPlane3D& plane);

  virtual const State & closestState(const HepPlane3D& plane) const;

  bool hasStateAt(const State::Location& value) const;

  virtual State* stateAt(const State::Location& value);

  virtual const State* stateAt(const State::Location& value) const;

  double chi2() const;

  virtual void reset();

  virtual Track* clone() const;

  void addToLhcbIDs(const LHCbID& value);

  void removeFromLhcbIDs(const LHCbID& value);

  virtual bool producedByAlgo(const HistoryFlag& value) const;

  virtual void setProducedByAlgo(const HistoryFlag& value);

  double chi2PerDoF() const;

  void setChi2PerDoF(double value);

  int nDoF() const;

  void setNDoF(int value);

  unsigned int flags() const;

  void setType(const TrackType& value);

  bool checkType(const TrackType& value) const;

  void setFlag(const Flag& value);

  bool checkFlag(const Flag& value) const;

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

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

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

  const State& physicsState() const;

  State& physicsState();

  void setPhysicsState(const State& value);

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

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

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

protected:

  enum flagsBits{typeBits    = 0,
                 historyBits = 7,
                 flagBits    = 16};

  enum flagsMasks{typeMask    = 0x7FL,
                  historyMask = 0xFF80L,
                  flagMask    = 0xF0000L};


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

private:

};

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

// Including forward declarations
#include "GaudiKernel/StatusCode.h"
#include "CLHEP/Geometry/Point3D.h"
#include "CLHEP/Geometry/Vector3D.h"
#include "CLHEP/Matrix/SymMatrix.h"


inline Track::~Track() 
{

  for (std::vector<State*>::iterator iter = m_states.begin();
  iter != m_states.end(); iter++)
  delete *iter;
        
}

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

inline const CLID& Track::classID()
{
  return CLID_Track;
}

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

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

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

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

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

inline void Track::setType(const TrackType& value)
{
  unsigned int val = (unsigned int)value;
  m_flags &= ~typeMask;
  m_flags |= ((((unsigned int)val) << typeBits) & typeMask);
}

inline bool Track::checkType(const TrackType& value) const
{
  unsigned int val = (unsigned int)value;
  return 0 != ( m_flags & typeMask & ( val << typeBits ));
}

inline void Track::setFlag(const Flag& value)
{
  unsigned int val = (unsigned int)value;
  m_flags |= ((((unsigned int)val) << flagBits) & flagMask);
}

inline bool Track::checkFlag(const Flag& value) const
{
  unsigned int val = (unsigned int)value;
  return 0 != ( m_flags & flagMask & ( val << flagBits ));
}

inline const std::vector<LHCbID>& Track::lhcbIDs() const 
{
  return m_lhcbIDs;
}

inline std::vector<LHCbID>& Track::lhcbIDs() 
{
  return m_lhcbIDs;
}

inline void Track::setLhcbIDs(const std::vector<LHCbID>& value) 
{
  m_lhcbIDs = value;
}

inline const State& Track::physicsState() const 
{
  return m_physicsState;
}

inline State& Track::physicsState() 
{
  return m_physicsState;
}

inline void Track::setPhysicsState(const State& value) 
{
  m_physicsState = value;
}

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

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

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

inline int Track::charge() const 
{

  double qP = m_physicsState.qOverP();
  return ( qP != 0. ? int(fabs(qP)/qP) : 0 );
        
}

inline unsigned int Track::nMeasurements() const 
{

  return m_lhcbIDs.size();
        
}

inline unsigned int Track::nStates() const 
{

  return m_states.size();
        
}

inline void Track::addToStates(State* value) 
{

  m_states.push_back( value );
        
}

inline void Track::removeFromStates(State* value) 
{

  std::vector<State*>::iterator iter =
    std::remove( m_states.begin(), m_states.end(), value );
  m_states.erase( iter, m_states.end() );
        
}

inline double Track::chi2() const 
{

  return ( m_chi2PerDoF * double(m_nDoF) );
        
}

inline void Track::reset() 
{

  m_chi2PerDoF   = 0;
  m_nDoF         = 0;
  m_flags        = 0;
  m_physicsState.reset();
  m_states.clear();
  m_lhcbIDs.clear();
        
}

inline void Track::addToLhcbIDs(const LHCbID& value) 
{

  m_lhcbIDs.push_back( value );
        
}

inline void Track::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() );
        
}

// Definition of Keyed Container for Track
typedef KeyedContainer<Track, Containers::HashMap> Tracks;



#endif 

---