ProcessFlag.h

Go to the documentation of this file.

#ifndef ProcessFlag_h
#define ProcessFlag_h

#include <map>
#include <iostream>

namespace EVENT{
  class LCCollection ;
}


namespace UTIL{

  enum struct ProcessorFlagBits{
    electrons,   
    muons,       
    taus,        
    neutrinos,   
    photons,     
    dquarks,     
    uquarks,     
    squarks,     
    cquarks,     
    bquarks,     
    higgsbb,     
    higgscc,     
    higgsdu,     
    higgsss,     
    higgsgg,     
    higgstautau, 
    higgsmumu,   
    higgsWW,     
    higgsZZ,     
    higgsgaga,   
    higgsgaZ,    
    higgsinv,    
    higgsother,  
    exotic,      
    unknown      
  } ;

  typedef ProcessorFlagBits PF;

  class ProcessFlag {

  public:

    ProcessFlag() = default ;
    ~ProcessFlag() = default ;

    ProcessFlag(const ProcessFlag& f) = default ;
    ProcessFlag& operator=(const ProcessFlag& f) = default ;

    ProcessFlag(int flag) : _flag(flag) {}


    ProcessFlag(const std::initializer_list<PF>& bits ) {
       for( auto bit : bits ) add(bit) ;
    }

    void add( PF bit ){
      _flag = _flag | ( 1 << (int) bit ) ; 
    } 

    bool addFSParticles(int pdg){
      auto m = _mapFS.find( pdg ) ;
      if( m != _mapFS.end() ){
    add( m->second ) ;
    return true ;
      }
      return false ;
    }
    bool addHiggsDecay(int pdg){
      auto m = _mapH.find( pdg ) ;
      if( m != _mapH.end() ){
    add( m->second ) ;
    return true ;
      }
      return false ;
    }

    ProcessFlag& operator=( int flag) { _flag = flag ; return *this ;}

    bool operator==(const ProcessFlag& f) const { return _flag == f._flag ; }

    bool contains(const ProcessFlag& f) const { return ( _flag & f._flag ) == f._flag ; }

  
    operator int() const { return _flag ; }

    bool has(PF bit) const { return (_flag & (1<< (int) bit)   ) ? true : false ; } 

  private:
    int _flag=0 ;

    std::map< int, PF > _mapFS =
    {
      { 11, PF::electrons },
      { 13, PF::muons     },
      { 15, PF::taus      },
      { 12, PF::neutrinos },
      { 14, PF::neutrinos },
      { 16, PF::neutrinos },
      { 22, PF::photons   },
      {  1, PF::dquarks   },
      {  2, PF::uquarks   },
      {  3, PF::squarks   },
      {  4, PF::cquarks   },
      {  5, PF::bquarks   }
    } ;
    std::map< int, PF > _mapH =
    {
      {  5, PF::higgsbb     },
      {  1, PF::higgsdu     },
      {  2, PF::higgsdu     },
      {  3, PF::higgsss     },
      {  4, PF::higgscc     },
      { 15, PF::higgstautau },
      { 13, PF::higgsmumu   },
      { 24, PF::higgsWW     },
      { 23, PF::higgsZZ     },
      { 22, PF::higgsgaga   },
      { 12, PF::higgsinv    },
      { 14, PF::higgsinv    },
      { 16, PF::higgsinv    },
      { 1000022, PF::higgsinv }
    } ;
 
  } ;


  inline std::ostream& operator<<(std::ostream& os, ProcessFlag flag ){

    os << std::hex << "0x" << (int) flag << std::dec << " -> |" ;

    if( flag.has( PF::electrons ) ) os << "electrons|" ;
    if( flag.has( PF::muons     ) ) os << "muons|" ;
    if( flag.has( PF::taus      ) ) os << "taus|" ;
    if( flag.has( PF::neutrinos ) ) os << "neutrinos|" ;
    if( flag.has( PF::photons   ) ) os << "photons|" ;
    if( flag.has( PF::dquarks   ) ) os << "dquarks|" ;
    if( flag.has( PF::uquarks   ) ) os << "uquarks|" ;
    if( flag.has( PF::squarks   ) ) os << "squarks|" ;
    if( flag.has( PF::cquarks   ) ) os << "cquarks|" ;
    if( flag.has( PF::bquarks   ) ) os << "bquarks|" ;
    if( flag.has( PF::higgsbb     ) ) os << "higgsbb|" ;
    if( flag.has( PF::higgsdu     ) ) os << "higgsdu|" ;
    if( flag.has( PF::higgsss     ) ) os << "higgsss|" ;
    if( flag.has( PF::higgscc     ) ) os << "higgscc|" ;
    if( flag.has( PF::higgstautau ) ) os << "higgstautau|" ;
    if( flag.has( PF::higgsmumu   ) ) os << "higgsmumu|" ;
    if( flag.has( PF::higgsWW     ) ) os << "higgsWW|" ;
    if( flag.has( PF::higgsZZ     ) ) os << "higgsZZ|" ;
    if( flag.has( PF::higgsgaga   ) ) os << "higgsgaga|" ;
    if( flag.has( PF::higgsgaZ    ) ) os << "higgsgaZ|" ;
    if( flag.has( PF::higgsinv    ) ) os << "higgsinv|" ;
    if( flag.has( PF::higgsother  ) ) os << "higgsother|" ;
    if( flag.has( PF::exotic      ) ) os << "exotic|" ;
    if( flag.has( PF::unknown     ) ) os << "unknown|" ;

    return os;
  }


  ProcessFlag decodeMCTruthProcess(const EVENT::LCCollection* mcps , int maxParticle=10);

}
#endif