Track.h

Go to the documentation of this file.

#ifndef ATLFAST_TRACK_H
#define ATLFAST_TRACK_H


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

// Atlfast classes.
#ifndef ATLFAST_TRACKTRAJECTORY_H
#include "AtlfastEvent/TrackTrajectory.h"
#endif

//#ifndef ATLFAST_IKINEMATIC_H
//#include "AtlfastEvent/IKinematic.h"
//#endif

#ifndef ATLFAST_IAODNAVIGATION_H
#include "AtlfastEvent/IAODNavigation.h"
#endif

//#ifndef ATLFAST_IKINEMATICBASE_H
//#include "AtlfastEvent/IKinematicBase.h"
//#endif

#ifndef ATLFAST_AODNAVIGATIONIMP_H
#include "AtlfastEvent/AODNavigationImp.h"
#endif

#ifndef ATLFAST_IAOOVISITOR_H
#include "AtlfastEvent/IAOOvisitor.h"
#endif

#include <iostream>


using ::HepSymMatrix;
class MsgStream;

namespace Atlfast {


  class IAOOvisitor;

  class Track : 
    virtual public IAODNavigation, private AODNavigationImp {
      
    private:

      TrackTrajectory m_trajectory;         
      TrackTrajectory m_truthTrajectory;    

      const HepMC::GenParticle* m_truth ;   
      HepSymMatrix m_smearMatrix;               
      int m_pdg_id;                          

    public:
      
      // -----------------------------------
      // Constructors

      Track( const TrackTrajectory& trajectory, 
             const HepMC::GenParticle* progenitor  );
      
      Track( const TrackTrajectory& truthTrajectory, 
             const TrackTrajectory& smearTrajectory,
             const HepMC::GenParticle* progenitor,
             const HepSymMatrix& matrix  );

      Track( const Track& other  );
      Track& operator=( const Track& other  );

      Track();

      virtual ~Track();


      virtual TrackTrajectory trajectory()    const; 
      virtual int pdg_id()                    const;
      const HepMC::GenParticle* truth()       const; 
      const HepSymMatrix smearMatrix()           const;
      void setMatrix(const HepSymMatrix& matrix)      ;
      const TrackTrajectory truthTrajectory() const; 

      virtual void accept(IAOOvisitor*) const;


    virtual HepLorentzVector momentum() const;
    virtual double eta() const;
    virtual double phi() const;
    virtual double pT()  const;
    virtual double eT()  const;
    virtual double mT()  const;
    virtual IKinematic* clone() const;
    virtual void print(const std::string& coor, std::string t="" ) const;

    };
  // inline methods                 //
  
  inline
    Track::Track( const TrackTrajectory& trajectory, 
                  const HepMC::GenParticle* progenitor  ) :
    AODNavigationImp(),
    m_trajectory(trajectory),
    m_truthTrajectory(trajectory),
    m_truth( progenitor ),
    m_smearMatrix(HepSymMatrix(5,0)),
    m_pdg_id(progenitor->pdg_id())
    { 
    }
      
  
  inline
    Track::Track( const TrackTrajectory& truthTrajectory, 
                  const TrackTrajectory& smearTrajectory,
                  const HepMC::GenParticle* progenitor,
                  const HepSymMatrix& matrix  ):
    AODNavigationImp(),
    m_trajectory(smearTrajectory),
    m_truthTrajectory(truthTrajectory),
    m_truth( progenitor ),
    m_smearMatrix(matrix),
    m_pdg_id(progenitor->pdg_id())
    { }

  
  inline
    Track::Track( const Track& other  ):
    Atlfast::IAOO(other),
    INavigable(other),
    I4Momentum(other),
    INavigable4Momentum(other),
    Atlfast::IKinematic(other),
    Atlfast::IAODNavigation(other),
    AODNavigationImp(other),
    m_trajectory(other.m_trajectory),
    m_truthTrajectory(other.m_truthTrajectory),
    m_truth( other.m_truth ),
    m_smearMatrix(other.m_smearMatrix),
    m_pdg_id(other.m_pdg_id)
    { }
      
  
  inline
    Track& Track::operator=( const Track& other  ){
    if(this == &other) return *this;
    AODNavigationImp::operator=(other);
    m_trajectory                = other.m_trajectory;
    m_truthTrajectory           = other.m_truthTrajectory;
    m_truth                     = other.m_truth;
    m_smearMatrix               = other.m_smearMatrix;
    m_pdg_id                    = other.m_pdg_id;
    return *this;
  }
    
  
  inline
    // 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::Track():
    AODNavigationImp(), 
    m_truth(0){}
  
  
  inline
    Track::~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

---