---

HepMC_helper.h

Go to the documentation of this file.

//=================================================
//
// HepMC_helper
//
// this .h file contains a number of useful utilities
// (predicate functions and constants) for manipulating
// the HepMC record.
//
// The PDG particle id for some common particles is
// defined for convenience; this can be changed when an
// official ATLAS mechanism is defined.
//
// Everything lives in the HepMC_helper namespace
//
// PELC: Added << operator for simple dump of a Particle
//  (this lives outside the namespace at the end)
// PS:   
//       Added SelectSpecifiedCharge class
//
// Authors: Hywel Phillips, Peter Clarke, Peter Sherwood
//
//
//===================================================

#ifndef __ATLFAST_HEPMC_HELPER_H
#define __ATLFAST_HEPMC_HELPER_H

#include <vector>
#include <iostream>
#include <cmath>
#include <float.h>

#include "HepMC/GenParticle.h"
#include "HepMC/GenVertex.h"
#include "HepMC/ParticleDataTable.h"
#include "HepMC/IO_PDG_ParticleDataTable.h"

#include "GaudiKernel/MsgStream.h"

#include "AtlfastCode/ChargeService.h"
#include "AtlfastCode/ReconstructedParticle.h"
namespace HepMC_helper {

  // The most common particle types are defined here as constants
  // just for our convenience
  //
  // An enum is not used because the user may well wish to supply
  // other values in general.
  //
  // In due course this should be replced by a ParticleID object
  // or some other general solution.
  
  const int DQUARK = 1;
  const int UQUARK = 2;
  const int SQUARK = 3;
  const int CQUARK = 4;
  const int BQUARK = 5;
  const int TQUARK = 6;
  
  const int ELECTRON = 11;
  const int NU_E     = 12;
  const int ELECTRON_NEUTRINO = 12;
  const int MUON     = 13;
  const int NU_MU    = 14;
  const int MUON_NEUTRINO = 14;
  const int TAU      = 15;
  const int NU_TAU   = 16;
  const int TAU_NEUTRINO = 16;
  
  const int GLUON    = 21;
  const int PHOTON   = 22;
  const int GAMMA    = 22;
  const int Z0       = 23;
  const int W        = 24;
  const int HIGGS    = 25;
  
  const int CHARGED_PION = 211;
  const int PI0 = 111;
  const int K0  = 311;
  const int CHARGED_KAON = 321;
  const int K0_L = 130;
  const int K0_S = 310;

  typedef HepMC::GenParticle Particle;
  
  
  //it seems like a good idea to have an PABC for the selectors
  //so you can pass the selector to the STL routines via the interface.
  //Unfortunaetly this does not work because the STL does  not wnat a pointer
  //or reference to the selector, but the selector itself. Passing it an
  //IMC selector (rather than a pointer or reference) does not work. PS.
  //*************************************************************************
  //*                                                                       *
  //*                 Interface class for MC selectors                      **
  //*                                                                       *
  //*************************************************************************
  class IMCselector{
  public:
    virtual IMCselector* create() const = 0;
    virtual bool operator()( const Particle* const) const = 0;
    virtual bool operator()( const Particle& p )    const = 0;
    virtual ~IMCselector(){};
  };
  //Using this class to wrap IMCselectors solves the problem mentioned above
  //*************************************************************************
  //*                                                                       *
  //*                      class MCselectorWrapper                          **
  //*                                                                       *
  //*************************************************************************
  class MCselectorWrapper{
  public:
    MCselectorWrapper(const IMCselector* selector): m_selector(selector){}
    bool operator()(const Particle* const p){ 
      return (*m_selector)(p) ;
    }
    const HepMC_helper::IMCselector* asIMCselector() const {return m_selector;}
  private:
    const IMCselector* m_selector;
  };
  //*************************************************************************
  //*                                                                       *
  //*           class All: public IMCselector                               **
  //*                                                                       *
  //*************************************************************************
  class All: public IMCselector {
    
  public:
    All() { } 
    IMCselector* create() const {return new All();}
    bool operator()( const Particle* const p )const;
    bool operator()( const Particle& p ) const {return this->operator()(&p);} 
  };
  //*************************************************************************
  //*                                                                       *
  //*  class IsFinalState                                                   **
  //*                                                                       *
  //* this predicate returns true if the input has no decay vertex          *
  //* i.e. the particle belongs to the final state.                         *
  //*                                                                       *
  //*************************************************************************
  class IsFinalState: public IMCselector {
    
  public:
    IsFinalState() { } 
    IMCselector* create() const  {return new IsFinalState();}
    bool operator()( const Particle* const p )const;
    bool operator()( const Particle& p ) const {return this->operator()(&p);} 
  };
  //*************************************************************************
  //*                                                                       *
  //*  class IsStatusxx                                                     *
  //*                                                                       **
  //* this predicate returns true if the input has status 21                *
  //* used in some very implementation dependent AtlfastFortran code        *
  //*                                                                       *
  //*************************************************************************
  class IsStatusxx: public IMCselector {   
  public:
    IsStatusxx(int stat):m_stat(stat) { } 
    IMCselector* create() const  {return new IsStatusxx(*this);}
    bool operator()( const Particle* const p )const;
    bool operator()( const Particle& p ) const {return this->operator()(&p);} 
  private:
    int m_stat;
  };
  
  //*************************************************************************
  //*                                                                       *
  //*                     class SelectType                                  **
  //*Note: it is charge blind, ie. is selects particle and anti-particle    *
  //*                                                                       *
  //*************************************************************************
  class SelectType: public IMCselector{
  public:
    SelectType( vector<int> requiredTypes);
    SelectType( int requiredType);
    SelectType(const SelectType& src );
    ~SelectType(){ }
    
    IMCselector* create() const {return new SelectType(*this);}
    
    bool operator() ( const Particle* const p ) const;
    bool operator()( const Particle& p ) const {return this->operator()(&p);} 
  private:      
    std::vector<int>  m_requiredTypes ;
  };
  //*************************************************************************
  //*                                                                       *
  //*                     class RejectType                                  **
  //*Note: it is charge blind, ie. is rejects particle and anti-particle    *
  //*                                                                       *
  //*************************************************************************
  
  class RejectType: public IMCselector{    
  public:
    RejectType( vector<int> ids);
    RejectType( int id);
    RejectType(const RejectType& src );
    ~RejectType(){  }
    
    
    IMCselector* create() const {return new RejectType(*this);}
    
    bool operator() ( const Particle* const p ) const{
      return !m_selectType(p);}
    bool operator()( const Particle& p ) const {return this->operator()(&p);} 
  private:
    SelectType m_selectType;
  };
  //*************************************************************************
  //*                                                                       *
  //*                     class Unseen                                      **
  //*                                                                       *
  //*************************************************************************
  class Unseen: public IMCselector {      
  public:
    // Constructors
    Unseen( vector<int> requiredTypes,
            double muonPtMax=6.0,
            double muonEtaMax=2.5);
    
    Unseen(const Unseen& src );
    // Destructor
    ~Unseen(){}
    IMCselector* create() const {return new Unseen(*this);}
    // The operator() method to determine acceptability of particle
    bool operator() ( const Particle* const p )const;
    bool operator() ( const Particle& p ) const {return this->operator()(&p);} 
  private:
    SelectType m_seltype;
    double m_muonPtMax ;
    double m_muonEtaMax ;
    IsFinalState m_ifs;
  };
  //*************************************************************************
  //*                                                                       *
  //*                     class IsCharged                                   **
  //*                                                                       *
  //*************************************************************************  
  class IsCharged:public IMCselector{
  private:
    Atlfast::ChargeService  m_chargeService;
  public:
    IsCharged() {}
    IMCselector* create() const  {return new IsCharged(*this);}
    bool operator() ( const Particle* const p )const;
    bool operator() ( const Particle& p ) const {return this->operator()(&p);} 
  };
  //*************************************************************************
  //*                                                                       *
  //*                     class MCCuts                                      **
  //*                                                                       *
  //*************************************************************************  
  class MCCuts: public IMCselector{
  public:
    MCCuts(double ptMin, double etaMax): m_ptMin(ptMin),m_etaMax(etaMax){}
    IMCselector* create() const  {return new MCCuts(*this);}

    bool operator() ( const Particle* const p )const;
    bool operator() ( const Particle& p ) const {return this->operator()(&p);} 
  private:
    double m_ptMin;
    double m_etaMax;
  };
  //*************************************************************************
  //*                                                                       *
  //*                     class SelectJetTag                                **
  //*                                                                       *
  //*************************************************************************  
  class SelectJetTag: public IMCselector {
  public:
    friend 
      MsgStream& operator<<(MsgStream&, const SelectJetTag&);
    // Constructor
    SelectJetTag(int id, double pt, double eta);
    // Destructor
    ~SelectJetTag(){};
    // The operator() method to determine acceptability of particle
    IMCselector* create() const {return new SelectJetTag(*this);}
    bool operator() ( const Particle* const p ) const;
    bool operator() ( const Particle& p ) const {return this->operator()(&p);} 
  private:
    int    m_id ;
    double m_ptMin ;
    double m_etaMax ;
  };
  //*************************************************************************
  //*                                                                       *
  //*                     class TauTag                                      **
  //*                                                                       *
  //*************************************************************************  
  class SelectTauTag: public IMCselector {
  public:
    friend 
      MsgStream& operator<<(MsgStream&, const SelectTauTag&);
    // Constructor
    SelectTauTag(double pt, double eta);
    // Destructor
    ~SelectTauTag(){};
    // The operator() method to determine acceptability of particle
    IMCselector* create() const {return new SelectTauTag(*this);}
    bool operator() ( const Particle* const p ) const;
    bool operator() ( const Particle& p ) const {return this->operator()(&p);} 
  private:
    SelectJetTag  m_jetTagSelector;
  };
  //*************************************************************************
  //*                                                                       *
  //*                     class SelectZ0                                    **
  //*                                                                       *
  //*************************************************************************  
  class SelectZ0: public IMCselector {
  public:
    friend 
      MsgStream& operator<<(MsgStream&, const SelectZ0&);
    // Constructor
    SelectZ0(double pt, double eta):m_kineCuts(eta, pt),m_z0Type(Z0){}
    // Destructor
    ~SelectZ0(){};
    // The operator() method to determine acceptability of particle
    IMCselector* create() const {return new SelectZ0(*this);}
    bool operator() ( const Particle* const p ) const;
    bool operator() ( const Particle& p ) const {return this->operator()(&p);} 
  private:
    MCCuts m_kineCuts;
    SelectType m_z0Type;
    int m_id ;    
    double m_ptMin ;
    double m_etaMax ;
  };
  //*************************************************************************
  //*                                                                       *
  //*                     class BFieldCutter                                **
  //*                                                                       *
  //*************************************************************************  
  class BFieldCutter: public IMCselector {
  public:
    
    BFieldCutter(bool fieldOn):m_chargeService(Atlfast::ChargeService()){
      m_ptCut = (fieldOn)? 0.5:0.0;
    }
   
    IMCselector* create() const {return new BFieldCutter(*this);}
    bool operator()( const Particle* const )const;
    bool operator()( const Particle& p ) const {return this->operator()(&p);} 
    
  private:
    double m_ptCut;
    Atlfast::ChargeService m_chargeService;    
  };
  //*************************************************************************
  //*                                                                       *
  //*                     class NCutter                                     **
  //*                                                                       *
  //*************************************************************************  
  class NCutter: public IMCselector {
    typedef  vector<IMCselector*> Selectors;
  private:
    Selectors m_selectors;
    
  public:
    // Constructors
    NCutter() {m_selectors.push_back( new All() );   }
    
    NCutter(const Selectors selectors){
    Selectors::const_iterator i=selectors.begin();
    for(; i != selectors.end(); ++i) m_selectors.push_back((*i)->create());
    }

    NCutter(const IMCselector* selector){ 
      m_selectors.push_back(selector->create() );
    }    
    
    NCutter( const NCutter& src ):IMCselector(){
      Selectors::const_iterator i=(src.m_selectors).begin();
      for(;i != (src.m_selectors).end(); ++i){
        m_selectors.push_back((*i)->create());
      }
    }  
    // Destructor
    ~NCutter() {
      Selectors::iterator i=m_selectors.begin();
      for(; i != m_selectors.end(); ++i) delete(*i);
    }

    IMCselector* create() const {return new NCutter(*this);}
    bool operator() ( const Particle* const ) const ;
    bool operator() ( const Particle& p ) const {return this->operator()(&p);} 
  };
  //*************************************************************************
  //*                                                                       *
  //*                     class AscendingEta                                **
  //*                                                                       *
  //*************************************************************************  
  class AscendingEta {
  public:
    bool operator() 
      ( const Particle* const a, 
        const Particle* const b ) const;
    bool operator() 
      ( const Particle& a, 
        const Particle& b ) const;
  };
  
  
}  // closing the namespace
#endif

---