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 "GaudiKernel/GaudiException.h"
#include "Event/State.h"
#include "Event/Measurement.h"
#include "Event/Node.h"
#include "Kernel/LHCbID.h"
#include "CLHEP/Geometry/Plane3D.h"
#include "GaudiKernel/KeyedObject.h"
#include "GaudiKernel/KeyedContainer.h"
#include "GaudiKernel/SmartRefVector.h"
#include <vector>


// Forward declarations
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& Ideal = "Rec/Track/Ideal";
  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:

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

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

  ~Track();

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

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

  void positionAndMomentum(HepPoint3D& pos,
                           HepVector3D& mom) const;

  HepPoint3D position() const;

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

  HepVector3D slopes() const;

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

  HepVector3D momentum() const;

  double p() const;

  double pt() const;

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

  void posMomCovariance(HepSymMatrix& cov6D) const;

  State & firstState() const;

  int charge() const;

  double chi2() const;

  unsigned int nStates() const;

  void addToStates(const State&  state);

  void removeFromStates(State* value);

  State & closestState(double z);

  const State & closestState(double z) const;

  State & closestState(const HepPlane3D& plane);

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

  bool hasStateAt(unsigned int location) const;

  State & stateAt(unsigned int location);

  const State & stateAt(unsigned int location) const;

  unsigned int nMeasurements() const;

  void addToMeasurements(const Measurement& meas);

  void removeFromMeasurements(Measurement* value);

  void addToNodes(Node* node);

  void removeFromNodes(Node* value);

  void addToLhcbIDs(const LHCbID& value);

  void removeFromLhcbIDs(const LHCbID& value);

  void addToAncestors(const Track & ancestor);

  virtual void reset();

  virtual Track* clone() const;

  bool checkType(unsigned int value) const;

  bool checkHistory(unsigned int value) const;

  bool checkHistoryFit(unsigned int value) const;

  void setFlag(unsigned int flag,
               bool ok);

  bool checkFlag(unsigned int flag) const;

  double chi2PerDoF() const;

  void setChi2PerDoF(double value);

  int nDoF() const;

  void setNDoF(int value);

  unsigned int flags() const;

  void setFlags(unsigned int value);

  unsigned int type() const;

  void setType(unsigned int value);

  unsigned int history() const;

  void setHistory(unsigned int value);

  unsigned int historyFit() const;

  void setHistoryFit(unsigned int value);

  unsigned int status() const;

  void setStatus(unsigned int value);

  unsigned int flag() const;

  unsigned int specific() const;

  void setSpecific(unsigned int value);

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

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

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

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

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

  const std::vector<Measurement*>& measurements() const;

  std::vector<Measurement*>& measurements();

  const std::vector<Node*>& nodes() const;

  std::vector<Node*>& nodes();

  const SmartRefVector<Track>& ancestors() const;

  SmartRefVector<Track>& ancestors();

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

  void addToAncestors(const Track* value);

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

  void clearAncestors();

protected:

  enum flagsBits{typeBits       = 0,
                 historyBits    = 5,
                 historyFitBits = 10,
                 statusBits     = 15,
                 flagBits       = 18,
                 specificBits   = 28};

  enum flagsMasks{typeMask       = 0x1FL,
                  historyMask    = 0x3E0L,
                  historyFitMask = 0x7C00L,
                  statusMask     = 0x38000L,
                  flagMask       = 0xFFC0000L,
                  specificMask   = 0xF0000000L};


  double                    m_chi2PerDoF;   
  int                       m_nDoF;         
  unsigned int              m_flags;        
  std::vector<LHCbID>       m_lhcbIDs;      
  std::vector<State*>       m_states;       
  std::vector<Measurement*> m_measurements; 
  std::vector<Node*>        m_nodes;        
  SmartRefVector<Track>     m_ancestors;    

private:

};

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

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


inline Track::~Track() 
{

  reset();
        
}

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::setFlags(unsigned int value) 
{
  m_flags = value;
}

inline unsigned int Track::type() const
{
  return (unsigned int)((m_flags & typeMask) >> typeBits);
}

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

inline unsigned int Track::history() const
{
  return (unsigned int)((m_flags & historyMask) >> historyBits);
}

inline void Track::setHistory(unsigned int value)
{
  unsigned int val = (unsigned int)value;
  m_flags &= ~historyMask;
  m_flags |= ((((unsigned int)val) << historyBits) & historyMask);
}

inline unsigned int Track::historyFit() const
{
  return (unsigned int)((m_flags & historyFitMask) >> historyFitBits);
}

inline void Track::setHistoryFit(unsigned int value)
{
  unsigned int val = (unsigned int)value;
  m_flags &= ~historyFitMask;
  m_flags |= ((((unsigned int)val) << historyFitBits) & historyFitMask);
}

inline unsigned int Track::status() const
{
  return (unsigned int)((m_flags & statusMask) >> statusBits);
}

inline void Track::setStatus(unsigned int value)
{
  unsigned int val = (unsigned int)value;
  m_flags &= ~statusMask;
  m_flags |= ((((unsigned int)val) << statusBits) & statusMask);
}

inline unsigned int Track::flag() const
{
  return (unsigned int)((m_flags & flagMask) >> flagBits);
}

inline unsigned int Track::specific() const
{
  return (unsigned int)((m_flags & specificMask) >> specificBits);
}

inline void Track::setSpecific(unsigned int value)
{
  unsigned int val = (unsigned int)value;
  m_flags &= ~specificMask;
  m_flags |= ((((unsigned int)val) << specificBits) & specificMask);
}

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 std::vector<State*>& Track::states() const 
{
  return m_states;
}

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

inline const std::vector<Measurement*>& Track::measurements() const 
{
  return m_measurements;
}

inline std::vector<Measurement*>& Track::measurements() 
{
  return m_measurements;
}

inline const std::vector<Node*>& Track::nodes() const 
{
  return m_nodes;
}

inline std::vector<Node*>& Track::nodes() 
{
  return m_nodes;
}

inline const SmartRefVector<Track>& Track::ancestors() const 
{
  return m_ancestors;
}

inline SmartRefVector<Track>& Track::ancestors() 
{
  return m_ancestors;
}

inline void Track::addToAncestors(const SmartRef<Track>& value) 
{
  m_ancestors.push_back(value);
}

inline void Track::addToAncestors(const Track* value) 
{
  m_ancestors.push_back(value);
}

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

inline void Track::clearAncestors() 
{
  m_ancestors.clear();
}

inline HepPoint3D Track::position() const 
{

   return firstState().position();
        
}

inline HepVector3D Track::slopes() const 
{

   return firstState().slopes();
        
}

inline HepVector3D Track::momentum() const 
{

   return firstState().momentum();
        
}

inline State & Track::firstState() const 
{

  // check at least the "first state" exists
  if ( m_states.empty() )
    throw GaudiException( "first (first) state not defined!",
                          "Track.h",
                          StatusCode::FAILURE );
  return *m_states[0];
        
}

inline int Track::charge() const 
{

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

inline double Track::chi2() const 
{

  return ( m_chi2PerDoF * double(m_nDoF) );
        
}

inline unsigned int Track::nStates() const 
{

  return m_states.size();
        
}

inline unsigned int Track::nMeasurements() const 
{

  unsigned int n = m_measurements.size();
  if (n == 0) n = m_lhcbIDs.size();
  return n;
        
}

inline void Track::addToNodes(Node* node) 
{

  m_nodes.push_back( node );
        
}

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

inline void Track::addToAncestors(const Track & ancestor) 
{

  m_ancestors.push_back( (Track*) &ancestor );
        
}

inline bool Track::checkType(unsigned int value) const 
{

  return type() == value;
        
}

inline bool Track::checkHistory(unsigned int value) const 
{

  return history() == value;
        
}

inline bool Track::checkHistoryFit(unsigned int value) const 
{

  return historyFit() == value;
        
}

inline void Track::setFlag(unsigned int flag,
                           bool ok) 
{

  unsigned int val = (((unsigned int) flag) << flagBits) & flagMask;
  if (ok) m_flags |= val;
  else m_flags &= ~val;
        
}

inline bool Track::checkFlag(unsigned int flag) const 
{

  unsigned int val = ((unsigned int) flag << flagBits);  
  bool ok = (0 != ( m_flags & flagMask & val ));
  return ok;
        
}

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



#endif 

---