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 <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& 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(),
            m_ancestors() {}

  ~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 positionAndMomentum(HepPoint3D& pos,
                                 HepVector3D& mom) 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;

  State & physicsState() const;

  int charge() const;

  double chi2() const;

  unsigned int nStates() const;

  void addToStates(State*  state,
                   bool inOrder = true);

  void addToStates(const State&  state,
                   bool inOrder = true);

  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(Measurement*  meas,
                         bool inOrder = true);

  void addToMeasurements(const Measurement& meas,
                         bool inOrder = true);

  void removeFromMeasurements(Measurement* value);

  void addToNodes(Node* node);

  void removeFromNodes(Node* value);

  void addToLhcbIDs(const LHCbID& value);

  void removeFromLhcbIDs(const LHCbID& value);

  void addToAncestors(Track & ancestor);

  void removeFromAncestors(const Track& value);

  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 std::vector<Track*>& ancestors() const;

  std::vector<Track*>& ancestors();

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;        
  std::vector<Track*>       m_ancestors;    

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() 
{

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

inline std::vector<Track*>& Track::ancestors() 
{
  return m_ancestors;
}

inline State & Track::physicsState() const 
{

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

inline int Track::charge() const 
{

  double qP = physicsState().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 void Track::addToStates(const State&  state,
                               bool inOrder ) 
{

          addToStates(state.clone(),inOrder);
        
}

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

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

inline unsigned int Track::nMeasurements() const 
{

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

inline void Track::addToMeasurements(const Measurement& meas,
                                     bool inOrder ) 
{

          addToMeasurements(meas.clone(),inOrder);
        
}

inline void Track::removeFromMeasurements(Measurement* value) 
{

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

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

  m_nodes.push_back( node );
        
}

inline void Track::removeFromNodes(Node* value) 
{

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

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(Track & ancestor) 
{

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

inline void Track::removeFromAncestors(const Track& value) 
{

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

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 

---