MissingETBase.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef XAODMISSINGET_VERSIONS_MISSINGETBASE_H
#define XAODMISSINGET_VERSIONS_MISSINGETBASE_H
 
 
#define EXTRACT_PX( _T_, _V_, _P_ )     \
  _T_ _V_(_P_.p4().Px())
 
#define EXTRACT_PY( _T_, _V_, _P_ )     \
  _T_ _V_(_P_.p4().Py())
 
#define EXTRACT_SCALED_PX( _T_, _V_, _P_, _S_ ) \
  _T_ _V_(_P_.p4().Px()*_S_)
 
#define EXTRACT_SCALED_PY( _T_, _V_, _P_, _S_ ) \
  _T_ _V_(_P_.p4().Py()*_S_)
 
#include "CxxUtils/bitmask.h"
 
#include <cstddef>
#include <cmath>
#include <vector>
#include <string>
#include <cstdint>
 
#include <tuple>

namespace MissingETBase
  {
    namespace Types
    {
      typedef uint64_t                             bitmask_t;         
      typedef std::vector<bitmask_t>               bitmask_vector_t;  
      typedef std::tuple<size_t,size_t>  indexedlink_t;      
    } // namespace MissingETBase::Types
    
    namespace Constants
    {
      static constexpr double precision  = 0.00001;      
 
      static constexpr size_t invalidIndex = size_t(-1); 
      static constexpr size_t unknownIndex = size_t(-1); 
 
      static const constexpr double wpxDefault = 1.0;          
      static constexpr double wpyDefault = 1.0;          
      static constexpr double wetDefault = 1.0;          
      static constexpr double wpxError   = 0.0;          
      static constexpr double wpyError   = 0.0;          
      static constexpr double wetError   = 0.0;          
 
      static const constexpr double cpxDefault = 0.0;          
      static constexpr double cpyDefault = 0.0;          
      static constexpr double cpzDefault = 0.0;          
      static constexpr double ceDefault = 0.0;           
      static constexpr double sumptDefault = 0.0;           
      static constexpr double cpxError = -9999999;          
      static constexpr double cpyError = -9999999;          
      static constexpr double cpzError = -9999999;          
      static constexpr double ceError = -9999999;           
      static constexpr double sumptError = -9999999;           

      static const std::string invalidString = "INVALID"; 
      static const std::string unknownString = "UNKNOWN"; 
      static const std::string emptyString = "EMPTY";     
      static const std::string nullString = "NULL";       
    } // namespace MissingETBase::Constants

    struct Numerical
    {
      static double               precision()    { return Constants::precision; }     
      static double               wpxDefault()   { return Constants::wpxDefault; }    
      static double               wpyDefault()   { return Constants::wpyDefault; }    
      static double               wetDefault()   { return Constants::wetDefault; }    
      static double               wpxError()     { return Constants::wpxError; }      
      static double               wpyError()     { return Constants::wpyError; }      
      static double               wetError()     { return Constants::wetError; }      
      static double               cpxDefault()   { return Constants::cpxDefault; }    
      static double               cpyDefault()   { return Constants::cpyDefault; }    
      static double               cpzDefault()   { return Constants::cpzDefault; }    
      static double               ceDefault()    { return Constants::ceDefault; }     
      static double               sumptDefault() { return Constants::sumptDefault; }  
      static double               cpxError()     { return Constants::cpxError; }      
      static double               cpyError()     { return Constants::cpyError; }      
      static double               cpzError()     { return Constants::cpzError; }      
      static double               ceError()      { return Constants::ceError; }       
      static double               sumptError()   { return Constants::sumptError; }       
      static size_t               invalidIndex() { return Constants::invalidIndex; }  
      static size_t               unknownIndex() { return Constants::unknownIndex; }  
      static Types::indexedlink_t invalidLink()  { return Types::indexedlink_t(Constants::invalidIndex,Constants::invalidIndex); } 
      static bool   isEqual(double x,double y) { return std::abs(x-y) < precision(); }
      static double divide(double x,double y) { return y != 0. ? x/y : 0.; }
    }; // struct Numerical

    struct Strings
    {
      static const std::string& invalidString()  { return Constants::invalidString; } 
      static const std::string& unknownString()  { return Constants::unknownString; } 
      static const std::string& emptyString()    { return Constants::emptyString; }   
      static const std::string& nullString()     { return Constants::nullString; }    
    }; // struct String
    
    struct Source
    {
      enum class Category : Types::bitmask_t {
        Refined         = 0x10000,   
        Truth           = 0x20000,   
        Calo            = 0x40000,   
        ID              = 0x80000,   
        UnknownCategory = 0x00000,   
        ATH_BITMASK
      };

      enum class Type : Types::bitmask_t {
        Electron    = 0x00001,   
        Photon      = 0x00002,   
        Tau         = 0x00004,   
        Muon        = 0x00008,   
        Jet         = 0x00010,   
        SoftEvent   = 0x00020,   
        Total       = 0x00040,   
        UnknownType = 0x00000,   
        ATH_BITMASK
      };

      enum class Region : Types::bitmask_t {
        Central        = 0x00100,  
        Endcap         = 0x00200,  
        Forward        = 0x00400,  
        FullAcceptance = 0x00000,  
        UnknownRegion  = 0x00000,   
        ATH_BITMASK
      };

      enum class TruthType : Types::bitmask_t {
        NonInt       = 0x21000, 
        Int          = 0x22000, 
        IntOut       = 0x24000, 
        TruthMuons   = 0x28000, 
        UnknownTruth = 0x00000,  
        ATH_BITMASK
      };

      enum class Signal : Types::bitmask_t {
        LCTopo        = 0x01000, 
        EMTopo        = 0x02000, 
        Track         = 0x04000, 
        UnknownSignal = 0x00000,  
        ATH_BITMASK
      };
             
      static Types::bitmask_t electron(Region reg=Region::FullAcceptance)                      { return ( Category::Refined | Type::Electron  ) | reg; }             
      static Types::bitmask_t photon(Region reg=Region::FullAcceptance)                        { return ( Category::Refined | Type::Photon    ) | reg; }             
      static Types::bitmask_t tau(Region reg=Region::FullAcceptance)                           { return ( Category::Refined | Type::Tau       ) | reg; }             
      static Types::bitmask_t muon(Region reg=Region::FullAcceptance)                          { return ( Category::Refined | Type::Muon      ) | reg; }             
      static Types::bitmask_t jet(Region reg=Region::FullAcceptance)                           { return ( Category::Refined | Type::Jet       ) | reg; }             
      static Types::bitmask_t softEvent(Region reg=Region::FullAcceptance)                     { return ( Category::Refined | Type::SoftEvent ) | reg; }             
      static Types::bitmask_t total(Region reg=Region::FullAcceptance)                         { return ( Category::Refined | Type::Total     ) | reg; }             
      static Types::bitmask_t signal(Signal sig=(Signal::LCTopo|Signal::Track),Region reg=Region::FullAcceptance)  { return ( Category::Refined | sig       ) | reg; }             
      static Types::bitmask_t track(Region reg=Region::FullAcceptance)                         { return signal(Signal::Track,reg); }             
      static Types::bitmask_t clusterLC(Region reg=Region::FullAcceptance)                     { return signal(Signal::LCTopo,reg); }             
      static Types::bitmask_t clusterEM(Region reg=Region::FullAcceptance)                     { return signal(Signal::EMTopo,reg); }             
      static Types::bitmask_t cluster(Region reg=Region::FullAcceptance)                       { return signal(Signal::LCTopo|Signal::EMTopo,reg); }

      static Types::bitmask_t truthNonInt()                         { return static_cast<Types::bitmask_t>(TruthType::NonInt); }
      static Types::bitmask_t truthInt(Region reg=Region::FullAcceptance)   { return TruthType::Int | reg; }
      static Types::bitmask_t truthIntOut()                         { return static_cast<Types::bitmask_t>(TruthType::IntOut); }
      static Types::bitmask_t truthMuons(Region reg=Region::FullAcceptance) { return TruthType::TruthMuons | reg; }
     
      static Types::bitmask_t caloLCTopo(Region reg=Region::FullAcceptance) { return ( Category::Calo | Signal::LCTopo ) | reg; }
      static Types::bitmask_t caloEMTopo(Region reg=Region::FullAcceptance) { return ( Category::Calo | Signal::EMTopo ) | reg; }
      static Types::bitmask_t idTrack(Region reg=Region::FullAcceptance)    { return ( Category::ID | Signal::Track )    | reg; }

      template <class E, class F>
      static bool hasPattern(E bits, F mask)
      { return static_cast<Types::bitmask_t>( bits & mask) == static_cast<Types::bitmask_t>(mask); }

      static bool hasCategory(Types::bitmask_t bits,Category cat)           { return hasPattern(bits,cat); }
      static bool hasType(Types::bitmask_t bits,Type type)                  { return hasPattern(bits,type); }
      static bool hasTruthType(Types::bitmask_t bits,TruthType type)        { return hasPattern(bits,type); }
      static bool hasSignal(Types::bitmask_t bits,Signal sig)               { return hasPattern(bits,sig);}
 
      static bool isElectronTerm(Types::bitmask_t bits,Region reg=Region::FullAcceptance) { return hasPattern(bits,electron(reg)); }
      static bool isPhotonTerm(Types::bitmask_t bits,Region reg=Region::FullAcceptance)   { return hasPattern(bits,photon(reg)); }
      static bool isTauTerm(Types::bitmask_t bits,Region reg=Region::FullAcceptance)      { return hasPattern(bits,tau(reg)); }
      static bool isMuonTerm(Types::bitmask_t bits,Region reg=Region::FullAcceptance)     { return hasPattern(bits,muon(reg)); }
      static bool isJetTerm(Types::bitmask_t bits,Region reg=Region::FullAcceptance)      { return hasPattern(bits,jet(reg)); }
      static bool isSoftTerm(Types::bitmask_t bits,Region reg=Region::FullAcceptance)     { return hasPattern(bits,softEvent(reg)); }
      static bool isTrackTerm(Types::bitmask_t bits,Region reg=Region::FullAcceptance)    { return hasPattern(bits,track(reg)); }
      static bool isTotalTerm(Types::bitmask_t bits,Region reg=Region::FullAcceptance)    { return hasPattern(bits,total(reg)); }
 
      static bool isTruthNonInt(Types::bitmask_t bits)                          { return hasPattern(bits,truthNonInt()); }
      static bool isTruthInt(Types::bitmask_t bits,Region reg=Region::FullAcceptance)    { return hasPattern(bits,truthInt(reg)); }
      static bool isTruthIntOut(Types::bitmask_t bits)                          { return hasPattern(bits,truthIntOut()); }
      static bool isTruthMuons(Types::bitmask_t bits,Region reg=Region::FullAcceptance)  { return hasPattern(bits,truthMuons(reg)); }
 
      static Types::bitmask_t unknown() { return static_cast<Types::bitmask_t>(Category::UnknownCategory); }
    };
 
} // namespace MissingETBase
 
/* @file MissingETBase.h
 *
 *  @name Globalnamespace operators
 */
bool operator==(MissingETBase::Types::indexedlink_t l0,MissingETBase::Types::indexedlink_t l1);
bool operator!=(MissingETBase::Types::indexedlink_t l0,MissingETBase::Types::indexedlink_t l1);
bool operator>=(MissingETBase::Types::indexedlink_t l0,MissingETBase::Types::indexedlink_t l1);
bool operator<=(MissingETBase::Types::indexedlink_t l0,MissingETBase::Types::indexedlink_t l1);
bool operator>(MissingETBase::Types::indexedlink_t l0,MissingETBase::Types::indexedlink_t l1);
bool operator<(MissingETBase::Types::indexedlink_t l0,MissingETBase::Types::indexedlink_t l1);
 
inline bool operator==(MissingETBase::Types::indexedlink_t l0,MissingETBase::Types::indexedlink_t l1)
{ return std::get<0>(l0) == std::get<0>(l1) && std::get<1>(l0) == std::get<1>(l1); }
 
inline bool operator!=(MissingETBase::Types::indexedlink_t l0,MissingETBase::Types::indexedlink_t l1)
{ return !operator==(l0,l1); }
 
inline bool operator>=(MissingETBase::Types::indexedlink_t l0,MissingETBase::Types::indexedlink_t l1)
{ return std::get<0>(l0) == std::get<0>(l1) ? std::get<1>(l0) >= std::get<1>(l1) : std::get<0>(l0) > std::get<0>(l1); }
 
inline bool operator<=(MissingETBase::Types::indexedlink_t l0,MissingETBase::Types::indexedlink_t l1)
{ return std::get<0>(l0) == std::get<0>(l1) ? std::get<1>(l0) <= std::get<1>(l1) : std::get<0>(l0) < std::get<0>(l1); }
 
inline bool operator>(MissingETBase::Types::indexedlink_t l0,MissingETBase::Types::indexedlink_t l1)
{ return std::get<0>(l0) == std::get<0>(l1) ? std::get<1>(l0) > std::get<1>(l1) : std::get<0>(l0) > std::get<0>(l1); }
 
inline bool operator<(MissingETBase::Types::indexedlink_t l0,MissingETBase::Types::indexedlink_t l1)
{ return std::get<0>(l0) == std::get<0>(l1) ? std::get<1>(l0) < std::get<1>(l1) : std::get<0>(l0) < std::get<0>(l1); }
 
#endif