---

HepMC_helper.cxx

Go to the documentation of this file.

#include "AtlfastUtils/HepMC_helper/HepMC_helper.h"
#include "AtlfastEvent/ParticleCodes.h"
#include "HepMC/GenParticle.h"
namespace HepMC_helper {
  using std::vector;
  using std::abs;
  //****************************************************************
  //*                    All                                       *
  //****************************************************************
  bool All::operator()( const Particle* const) const {
    return true;
  }
  bool All::operator() ( const Particle& p ) const {
    return this->operator()(&p);
  } 
  IMCselector* All::create() const {return new All();}
  //****************************************************************
  //*                    IsFinalState                              *
  //***********************final*****************************************
  IsFinalState::IsFinalState()  {}
    //: m_status(IsStatusxx(1))

  bool IsFinalState::operator()( const Particle* const p ) const {
    //p->status()%100 see ChangeLog 22/10/02
    // return ( p->end_vertex() || (p->status()%100) != 1)? false:true;}
    // return ( p->end_vertex() || !m_status)? false:true;}
    return ( p->barcode() < 100000 && ( p->status()==1 || p->status()>100) ) ? true:false;
  }

  bool IsFinalState::operator() ( const Particle& p ) const {
    return this->operator()(&p);
  } 
  IMCselector* IsFinalState::create() const {return new IsFinalState(*this);}
    //****************************************************************
  //*                    IsStatusxx                              *
  //***********************final**************************************
  bool IsStatusxx::operator()( const Particle* const p ) const {
    return ( p->status()%100 == m_stat)? true:false;}
  bool IsStatusxx::operator() ( const Particle& p ) const {
    return this->operator()(&p);
  } 
  IMCselector* IsStatusxx::create() const {return new IsStatusxx(*this);}
  //****************************************************************
  //* RMS                  NCutter                                 *
  //****************************************************************
  bool NCutter::operator()( const Particle* const p ) const {
    for (vector<IMCselector*>::const_iterator i = m_selectors.begin();
         i != m_selectors.end(); i++) { 
      if ( !(*i)->operator()(p) ) return false;
    }
    return true;
  }
  bool NCutter::operator() ( const Particle& p ) const {
    return this->operator()(&p);
  } 
  IMCselector* NCutter::create() const {return new NCutter(*this);}
  //****************************************************************
  //*                    SelectType                                *
  //****************************************************************
  SelectType::SelectType(vector<int> types):m_requiredTypes(types){}
  SelectType::SelectType(int type){m_requiredTypes.push_back(type);}
  SelectType::SelectType(const SelectType& rhs):
    IMCselector(),
    m_requiredTypes(rhs.m_requiredTypes){}

  bool SelectType::operator() ( const Particle* const p ) const {
    vector<int>::const_iterator itype = m_requiredTypes.begin();
    for(; itype < m_requiredTypes.end(); ++itype ){ 
      if( abs(p->pdg_id()) == (*itype) ) return true ;
    }
    return false ;
  }
  bool SelectType::operator() ( const Particle& p ) const {
    return this->operator()(&p);
  } 
  IMCselector* SelectType::create() const {return new SelectType(*this);}
  
  //****************************************************************
  //*                    RejectType                                *
  //****************************************************************
  
  RejectType::RejectType(int type): m_selectType(type){}
  RejectType::RejectType(vector<int> types): m_selectType(types){}
  RejectType::RejectType(const RejectType& rhs):
    IMCselector(), 
    m_selectType(rhs.m_selectType){}

  bool RejectType::operator() ( const Particle* const p ) const{
      return !m_selectType(p);}
  bool RejectType::operator()( const Particle& p ) const {
      return this->operator()(&p);} 
  IMCselector* RejectType::create() const {return new RejectType(*this);}

  //****************************************************************
  //*                     IsCharged                                *
  //****************************************************************

  bool IsCharged::operator() ( const Particle* const p )const{
    
    double charge = m_chargeService(p);
    if(charge==0) return false;
    return true ;       
  }

  bool IsCharged::operator() ( const Particle& p ) const {
    return this->operator()(&p);
  } 
  IMCselector* IsCharged::create() const  {return new IsCharged(*this);}

  //****************************************************************
  //*                     MCCuts                                   *
  //****************************************************************
  MCCuts::MCCuts(double ptMin, double etaMax): 
    m_ptMin(ptMin),m_etaMax(etaMax){}
  bool MCCuts::operator() ( const Particle* const p )const {
    if (p->momentum().perp() < m_ptMin) return false;
    if (abs(p->momentum().pseudoRapidity()) > m_etaMax) return false;
    return true;
  }

  bool MCCuts::operator() ( const Particle& p ) const {
    return this->operator()(&p);
  } 
  IMCselector* MCCuts::create() const  {return new MCCuts(*this);}
  

  //****************************************************************
  //*                    Unseen                                    *
  //****************************************************************
  Unseen::Unseen( vector<int> requiredTypes,
                  double muonPtMax,
                  double muonEtaMax): 
    m_seltype( SelectType(requiredTypes) ),
    m_muonPtMax( muonPtMax ),
    m_muonEtaMax( muonEtaMax ){
  }
  
  Unseen::Unseen(const Unseen& src ): 
    IMCselector(),
    m_seltype( src.m_seltype ),
    m_muonPtMax( src.m_muonPtMax ),
    m_muonEtaMax( src.m_muonEtaMax ){ 
  }
  bool Unseen::operator() ( const Particle* const p )const{
    if(m_seltype(p)) return true;
    if( abs(p->pdg_id()) == 13){
      if(!m_ifs(p)) return false;
      if(abs(p->momentum().pseudoRapidity()) > m_muonEtaMax) return true;
      if(    p->momentum().perp()            < m_muonPtMax ) return true;
    }
    return false ;       
  }
  IMCselector* Unseen::create() const {return new Unseen(*this);}
  // The operator() method to determine acceptability of particle
  bool Unseen::operator() ( const Particle& p ) const {
    return this->operator()(&p);
  } 
  //****************************************************************
  //*                    SelectJetTag                              *
  //****************************************************************
  
  SelectJetTag::SelectJetTag(int id, double pt, double eta):
    m_id(abs(id)), m_ptMin(pt), m_etaMax(eta){
  }
  bool SelectJetTag::operator() ( const Particle* const p ) const{
    // check on kinematics
    if( abs(p->pdg_id())                    !=     m_id) return false ; 
    if( p->momentum().perp()                 <  m_ptMin) return false ; 
    if((abs(p->momentum().pseudoRapidity())) > m_etaMax) return false ; 
    if(p->end_vertex()){
      
      HepMC::GenVertex::particle_iterator firstChild = 
        p->end_vertex()->particles_begin(HepMC::children);
      
      HepMC::GenVertex::particle_iterator endChild = 
        p->end_vertex()->particles_end(HepMC::children);
      
      HepMC::GenVertex::particle_iterator thisChild = firstChild; 
      
      //Should be vetoing this tag if it has a child of the same pdg id
      // following kludge due to fact that parents are included in
      // the list of children!
      for(; thisChild!=endChild; ++thisChild){
        if(abs((*thisChild)->pdg_id()) == m_id) return false;
      }
    }
    return true ;       
  }
  IMCselector* SelectJetTag::create() const {return new SelectJetTag(*this);}
  bool SelectJetTag::operator() ( const Particle& p ) const {
    return this->operator()(&p);
  } 


  //****************************************************************
  //*                    SelectTauTag                              *
  //****************************************************************

  SelectTauTag::SelectTauTag(double pt, double eta):
    m_jetTagSelector(ParticleCodes::TAU, pt, eta){
  }
  bool SelectTauTag::operator() ( const Particle* const p ) const{
    if(p->end_vertex()){
      
      HepMC::GenVertex::particle_iterator firstChild = 
        p->end_vertex()->particles_begin(HepMC::children);
      
      HepMC::GenVertex::particle_iterator endChild = 
        p->end_vertex()->particles_end(HepMC::children);
      
      HepMC::GenVertex::particle_iterator thisChild = firstChild; 
      
      // Reject if the Tau does not decay hadronically
      for(; thisChild!=endChild; ++thisChild){
        if(abs((*thisChild)->pdg_id()) == 11 || 
           abs((*thisChild)->pdg_id()) == 13 || 
           abs((*thisChild)->pdg_id()) == 15 ) return false;
      }
    }
    return m_jetTagSelector(p);
  }
  
  IMCselector* SelectTauTag::create() const {return new SelectTauTag(*this);}
  
  bool SelectTauTag::operator() ( const Particle& p ) const {
    return this->operator()(&p);
  } 

  //****************************************************************
  //*                    SelectZ0                                  *
  //****************************************************************

  bool SelectZ0::operator() ( const Particle* const p ) const{
    if(!m_z0Type(p))   return false;
    if(!m_kineCuts(p)) return false;
    return true;
  } 
  IMCselector* SelectZ0::create() const {return new SelectZ0(*this);}
  bool SelectZ0::operator() ( const Particle& p ) const {
    return this->operator()(&p);
  } 

  //****************************************************************
  //*                    BFieldCutter                              *
  //****************************************************************
  
  bool BFieldCutter::operator()(const Particle* const a) const {
    if(m_chargeService(a) == 0.) return true;
    return (a->momentum().perp()<m_ptCut) ? false:true;
  }
   
  IMCselector* BFieldCutter::create() const {return new BFieldCutter(*this);}
  bool BFieldCutter::operator()( const Particle& p ) const {
    return this->operator()(&p);
  } 

  //****************************************************************
  //*                    AscendingEta                              *
  //****************************************************************

  bool AscendingEta::operator() ( const Particle* const a, 
                                  const Particle* const b  ) const{ 
    return( a->momentum().pseudoRapidity() < 
            b->momentum().pseudoRapidity() ); }
  bool AscendingEta::operator() ( const Particle& a, 
                                  const Particle& b  ) const{ 
    return( a.momentum().pseudoRapidity() < 
            b.momentum().pseudoRapidity() ); 
  }

}  // closing the namespace

---