MissingETCompositionBase.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef XAODMISSINGET_VERSIONS_MISSINGETCOMPOSITIONBASE_H
#define XAODMISSINGET_VERSIONS_MISSINGETCOMPOSITIONBASE_H
 
#include "xAODMissingET/versions/MissingETBase.h"
 
#include "xAODBase/IParticle.h"
#include "xAODBase/IParticleContainer.h"
 
#include "AthContainers/ConstDataVector.h"
#include "AthLinks/ElementLink.h"
#include "CxxUtils/bitmask.h"
 
#include "xAODMissingET/MissingETContainer.h"
 
#include "xAODJet/JetContainer.h"
 
#include <vector>
#include <iterator>

namespace MissingETBase
{
  namespace Types
  {
    typedef ElementLink<xAOD::MissingETContainer> metlink_t;
    typedef ElementLink<xAOD::JetContainer> jetlink_t;
    typedef ElementLink<xAOD::IParticleContainer> objlink_t;
 
    typedef ConstDataVector<xAOD::IParticleContainer> const_signal_vector_t;
    
    typedef std::vector<objlink_t>        objlink_vector_t;
    typedef std::vector<const xAOD::IParticle*> object_vector_t;     
  } // namespace MissingETBase::Types

  struct Status
  {
    enum class Reco : Types::bitmask_t {
      Total           = 0x01000000, 
      ContributedTerm = 0x02000000, 
      CorrectedTerm   = 0x04000000, 
      AlternativeTerm = 0x08000000, 
      StandAlone      = 0x00000000, 
      ATH_BITMASK
    };

    enum class Vertex : Types::bitmask_t {
      Primary         = 0x00100000, 
      Secondary       = 0x00200000, 
      Event           = 0x00010000, 
      Nominal         = 0x00020000, 
      Specific        = 0x00040000, 
      NoVertex        = 0x00000000, 
      ATH_BITMASK
    };

    enum class Correction : Types::bitmask_t {
      Corrected       = 0x00001000, 
      Pileup          = 0x00001100, 
      PileupCalo      = 0x00001110,  
      PileupTrack     = 0x00001120, 
      PileupSTVF      = 0x00001121, 
      PileupJetVertex = 0x00001122, 
      PileupJetArea   = 0x00001140, 
      NotCorrected    = 0x00000000,  
      ATH_BITMASK
    };

    static const Types::bitmask_t clearedStatusTag   = Reco::StandAlone      | Vertex::NoVertex | Correction::NotCorrected;     
    static const Types::bitmask_t generalSummedTag   = Reco::Total           | Vertex::NoVertex | Correction::NotCorrected;     
    static const Types::bitmask_t generalContribTag  = Reco::StandAlone      | Vertex::NoVertex | Correction::NotCorrected;     
    static const Types::bitmask_t generalHardTermTag = Reco::ContributedTerm | Vertex::Specific | Correction::Pileup;           
    static const Types::bitmask_t generalSoftTermTag = Reco::ContributedTerm | Vertex::NoVertex | Correction::NotCorrected;     
    static Types::bitmask_t clearedStatus()       { return clearedStatusTag; }                        
    static Types::bitmask_t summedTerm()          { return generalSummedTag; }                        
    static Types::bitmask_t contributedTerm()     { return generalContribTag; }                       
    static Types::bitmask_t contributedHardTerm() { return generalHardTermTag; }                      
    static Types::bitmask_t contributedSoftTerm() { return generalSoftTermTag; }                      
 
    struct Tags 
    {
      static Types::bitmask_t setPattern(Reco rec, Vertex vtx, Correction cor) { return ( rec | vtx ) | cor; }
 
      static Types::bitmask_t total(Vertex vtx=Vertex::Nominal,Correction cor=Correction::NotCorrected)              { return setPattern(Reco::Total,vtx,cor); }
      static Types::bitmask_t contributedTerm(Vertex vtx=Vertex::Nominal,Correction cor=Correction::NotCorrected)    { return setPattern(Reco::ContributedTerm,vtx,cor); }
      static Types::bitmask_t correctedTerm(Vertex vtx=Vertex::Nominal,Correction cor=Correction::Corrected) { return setPattern(Reco::CorrectedTerm,vtx,cor); }
      static Types::bitmask_t alternativeTerm(Vertex vtx=Vertex::Nominal,Correction cor=Correction::NotCorrected)     { return setPattern(Reco::AlternativeTerm,vtx,cor); }
 
      template<class T>
      static bool hasPattern(Types::bitmask_t sw, T pat) { return ( sw & pat ) == static_cast<Types::bitmask_t>(pat); }
 
      static bool isTotal(Types::bitmask_t sw)           { return hasPattern(sw,Reco::Total); }
      static bool isContributedTerm(Types::bitmask_t sw) { return hasPattern(sw,Reco::ContributedTerm); }
      static bool isAlternativeTerm(Types::bitmask_t sw) { return hasPattern(sw,Reco::AlternativeTerm); }
      static bool isStandAlone(Types::bitmask_t sw)      { return hasPattern(sw,Reco::StandAlone); }
    }; // struct MissingETBase::Status::Tags
  }; // struct MissingETBase::Status
 
  namespace Container
  { 
    template<class ITER>
    size_t iteratorDiff(ITER first,ITER last) { return (size_t)(std::distance(first,last)); }
    template<class ITER>
    ITER iteratorAdvance(ITER iter,size_t step) { ITER fIter(iter); std::advance(iter,step); return fIter; }
  } // namespace MissingETBase::Container

  namespace UsageHandler
  {
    enum Policy {
      AllCalo       = 0x0010, 
      OnlyCluster   = 0x0011, 
      OnlyTrack     = 0x0012, 
      TrackCluster  = 0x0014, 
      PhysicsObject = 0x0020, 
      ParticleFlow  = 0x0040, 
      TruthParticle = 0x0100, 
      UnknownPolicy = 0x0000  };
  } // namespace MissingETBase::OverlapHandler
} // namespace MissingETBase
#endif