---

ReconstructedParticle.h

Go to the documentation of this file.

// ================================================
// This file contains:
//
//              ReconstructedParticle class
//
//           ReconstructedParticleCollection   
// ================================================
//
// THIS TEXT TO BE REPLACED BY ATLAS STANDARD FORMAT
//
//
// Namespace: ATLFast::
//
// class: ReconstructedParticle
//
// Description:
//
//   ReconstructedParticle is used to represent most simple particles such as 
//   Electron, Muon, Photon, etc. The motivation being that all particles are
//   the same type from the point of view of kinematic state variables, 
//   and are only differentiated by having a different "label".
//
//   It implements an "IKinematic" interface which is
//   designed to standardise kimematic attribute query method names.
//
//   Ongoing points during development:
//
//   1 This is of course not a proven concept at this stage.
//     However we follow the principle of "try the simplest thing first"
//     Thus we propose this as the highest level analysis entity class
//     in order to see if it works.
//
//   2 This is all without prejudice to how we chose to
//     represent jets, tracks, clusters...
//
//   3 It was developed during the first phase of ATLFAST++ re-engineering
//     and inclusion in the ATLAS (Gaudi/Athena) analysis framework. 
//     It is therefore one of the first implementations of such analysis classes,
//     and as such should be seen as a prototype which may be superceeded
//     in concept.
// 
//   4 At the present time we have not solved the association/relationship
//     to other entities. This is a deep problem which is wider than
//     Atlfast.
//  
//
// Authors:
//    P.Clarke, H.Phillips, E.Richter-Was, P.Sherwood, R.Steward
//
// Written:
//    7-June-2000
// Revised:
//
//
// ................................................................
//
#ifndef ATLFAST_RECONSTRUCTEDPARTICLE_H
#define ATLFAST_RECONSTRUCTEDPARTICLE_H



// Gaudi/Athena 
#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/ObjectVector.h"

// Other
#include "CLHEP/Vector/LorentzVector.h"
#include "HepMC/GenParticle.h"

// Atlfast
#include "AtlfastCode/IKinematic.h"
#include "AtlfastCode/AssociationManager.h"

//include "Atlfast/Phi.h"

//Class ID for ReconstructedParticle class
static const CLID CLID_ATLFAST_RECONSTRUCTED_PARTICLE=2305 ;



//******************************************
//      ReconstructedParticle class
//
// See description at head of this file 
//******************************************


namespace Atlfast {
  class ReconstructedParticle: 
    public IKinematic,
    public ContainedObject,  
    public AssociationManager 
    {
      
    public:
      
      //.............
      // Constructors
      
      // This is the principle constructor needed by users
      ReconstructedParticle(const int pdg_id, 
                            const HepLorentzVector& vec,
                            const HepMC::GenParticle* progenitor ) : 
        IKinematic(),
        ContainedObject(),
        AssociationManager(),
        m_pdg_id(pdg_id), 
        m_momentum(vec), 
        m_truth(progenitor) {}
      
      // Copy constructors
      ReconstructedParticle( const ReconstructedParticle& src ) :
        IKinematic(),
        ContainedObject(),
        AssociationManager( src ),
        m_pdg_id(src.m_pdg_id), 
        m_momentum(src.m_momentum), 
        m_truth(src.m_truth) 
       { }
      
      ReconstructedParticle( const ReconstructedParticle* src ) :
        IKinematic(),
        ContainedObject(),
        AssociationManager( *src ),
        m_pdg_id(src->m_pdg_id), 
        m_momentum(src->m_momentum), 
        m_truth(src->m_truth) {}

      // default constructor required by Gaudi
      ReconstructedParticle() : 
        IKinematic(),
        ContainedObject(), 
        AssociationManager(),
        m_pdg_id(0), 
        m_momentum(HepLorentzVector(0.0,0.0,0.0,0.0)), 
        m_truth(0) {}
    

      virtual ~ReconstructedParticle() {}
      
      
      //..............................................
      // Methods required by IKinematic interface to kinematic quantitites
      // See interface documentation for description.
      
      virtual HepLorentzVector momentum() const {return m_momentum;} 
      virtual double  eta() const { return m_momentum.pseudoRapidity() ;}
      virtual double  phi() const { return m_momentum.phi() ;  } 
      virtual double  pT()  const { return m_momentum.perp() ;}
      virtual double  eT()  const { 
        return m_momentum.e()*m_momentum.perp()/m_momentum.rho() ;}
      virtual double  mT()  const { return m_momentum.mt() ;}
      
      
      //........................
      //Other user methods
      
     int pdg_id() const { return m_pdg_id ; }
     
     const HepMC::GenParticle* truth() const { return m_truth ; }
     
     //.........................
     // Athena mandatory methods
     static const  CLID& classID()    
       { return CLID_ATLFAST_RECONSTRUCTED_PARTICLE; }
     virtual const CLID& clID() const 
       {  return CLID_ATLFAST_RECONSTRUCTED_PARTICLE; }
     
      // Input streamer
      virtual StreamBuffer& serialize(StreamBuffer& s);

      // Output streamer
      virtual StreamBuffer& serialize(StreamBuffer& s) const;

    private:
     
     // My pdg identity code
     int m_pdg_id ;
     
     // My 4-momentum
     HepLorentzVector m_momentum ;
     
     // Pointer to the MC generated particle from which this was derived
     // FIXME: This is unsafe but awaits an agreed fix to be implemented
     const HepMC::GenParticle* m_truth ;
     
    };
  
  
} // end of namespace bracket
#endif

---