---

Track.h

Go to the documentation of this file.

// ================================================
// Track class description
// ================================================
//
// THIS TEXT TO BE REPLACED BY ATLAS STANDARD FORMAT
//
// Namespace Atlfast::
//
// class: Track
//
// Authors: P.Clarke, H.Phillips, E.Richter-Was, P.Sherwood, R.Steward
//
// Description: 
//
//  Class to represent Tracks 
//
//  NOT included yet are:
//
//    1. Up to 6 mothers ? as I didnt understand how there could be more
//       than 1 ?
//    
//    2. Correlation coefficients. The thought is that if these go in they
//       go into ITrackTrajectory. Need to understand their use more.
//
//..................................................


#ifndef ATLFAST_TRACK_H
#define ATLFAST_TRACK_H


// CLHEP, HepMC
#include "CLHEP/Vector/ThreeVector.h"
#include "HepMC/GenParticle.h"
#include "CLHEP/Matrix/Matrix.h"

// Atlfast classes.
#include "AtlfastEvent/ITrackTrajectory.h"
#include "AtlfastEvent/TrackTrajectory.h"
#include "AtlfastEvent/AssociationManager.h"

// Gaudi
#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/MsgStream.h"


//Class ID for Track class
static const CLID CLID_ATLFAST_Track=2306 ;

using ::HepMatrix;

namespace Atlfast {


  //........................................
  class Track : 
    virtual public ITrackTrajectory, 
    virtual public ContainedObject, 
    public AssociationManager
    {
      
    private:
      
      // A representation of the kinematic information assocated with 
      // this Track. This can be anthing suitable, all that is important is
      // that it can be used to honour the ITrackTrajectory interface.
      TrackTrajectory m_trajectory;
      TrackTrajectory m_truthTrajectory;
      // Mc truth particle from which this was created
      const HepMC::GenParticle* m_truth ;
      HepMatrix m_smearMatrix;
      
    public:
      
      // -----------------------------------
      // Constructors
      
      // Meaningful constructor to be used by clients
      Track( const TrackTrajectory& trajectory, 
             const HepMC::GenParticle* progenitor  ) 
        : ContainedObject(),
        AssociationManager(),
        m_trajectory(trajectory),
        m_truthTrajectory(trajectory),
        m_truth( progenitor ),
        m_smearMatrix(HepMatrix(5,5,0.))
        { }
      
      Track( const TrackTrajectory& truthTrajectory, 
             const TrackTrajectory& smearTrajectory,
             const HepMC::GenParticle* progenitor,
             const HepMatrix& matrix  ) 
        : ContainedObject(),
        AssociationManager(),
        m_trajectory(smearTrajectory),
        m_truthTrajectory(truthTrajectory),
        m_truth( progenitor ),
        m_smearMatrix(matrix)
        { }
      
      // Copy
      Track( const Track& src  ) 
        : ContainedObject( ),
        AssociationManager(src),
        m_trajectory(src.m_trajectory),
        m_truthTrajectory(src.m_truthTrajectory),
        m_truth( src.m_truth ),
        m_smearMatrix(src.m_smearMatrix)
        { }
      
      // Default which seems to be required by Athena, although doesnt have any 
      // meaning for the Track class. Hence a bogus trajectory has to be invented.
      Track() 
        : ContainedObject(), 
        AssociationManager(),
        m_trajectory( TrackTrajectory( 0,0,Phi(),0,0,0,HepPoint3D()
                                       ) 
                      ),
        m_truthTrajectory( TrackTrajectory( 0,0,Phi(),0,0,0,HepPoint3D()
                                            ) 
                           ),
        m_truth(NULL),
        m_smearMatrix(HepMatrix(5,5,0.))
        { }
      
      // Destructor
      //  Track() 
      //   : ContainedObject(), 
      //     AssociationManager(),
      //     m_trajectory( TrackTrajectory( Hep3Vector(1.,1.,1.), 
      //                                       Hep3Vector(0,0,0), 
      //                                       1., 
      //                                       0. 
      //                                      ) 
      //                    ),
      //     m_truth(NULL)
      //   { }
      
      // Destructor
      ~Track() {}
      
      // ------------------------------------------------
      // Methods to honour ITrackTrajectory interface 
      virtual Hep3Vector threeMomentum() const { 
        return Hep3Vector(m_trajectory); }
      virtual operator Hep3Vector() const { return Hep3Vector(m_trajectory); }
      virtual double  eta() const { return m_trajectory.eta() ;}
      virtual double  phi() const { return m_trajectory.phi() ;} 
      virtual double  pT()  const { return m_trajectory.pT() ;}
      virtual double  impactParameter() const { 
        return m_trajectory.impactParameter() ;}
      virtual double  zPerigee()     const { return m_trajectory.zPerigee() ;}
      virtual double  cotTheta()     const { return m_trajectory.cotTheta() ;}
      virtual double  invPtCharge()  const { 
        return m_trajectory.invPtCharge();}  
      virtual double  radius()       const { return m_trajectory.radius() ;}
      virtual HepPoint3D startPoint() const { 
        return m_trajectory.startPoint(); }
      virtual int     signOfCharge() const { 
        return m_trajectory.signOfCharge() ;}
      virtual TrackTrajectory trajectory() const {return m_trajectory;}
      virtual double  curvature() const {return m_trajectory.curvature() ;}
      
      // --------------------------------------------------
      // Access to MC truth particle from which this was created
      const HepMC::GenParticle* truth() const { return m_truth ; }
      const HepMatrix smearMatrix() const {return m_smearMatrix;}
      void setMatrix(const HepMatrix& matrix) {m_smearMatrix = matrix;}
      const TrackTrajectory truthTrajectory() const {return m_truthTrajectory;}
      // --------------------------------
      // Athena mandatory methods
      static const CLID& classID() { return CLID_ATLFAST_Track; }
      virtual const CLID& clID() const {  return CLID_ATLFAST_Track; }
      
    };
  
  
  // ................................................
  // Message stream operator for simple debug output
  
  MsgStream& operator << ( MsgStream& s, const Track& t ) ;
  MsgStream& operator << ( MsgStream& s, const Track* t ) ;
  
  
} // end of namespace 


#endif

---