/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODMissingET/xAODMissingET/versions/MissingETCompositionBase.h

// -*- c++ -*-
#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 "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 Reco { 
      Total           = 0x01000000, 
      ContributedTerm = 0x02000000, 
      CorrectedTerm   = 0x04000000, 
      AlternativeTerm = 0x08000000, 
      StandAlone      = 0x00000000   };
    enum Vertex {
      Primary         = 0x00100000, 
      Secondary       = 0x00200000, 
      Event           = 0x00010000, 
      Nominal         = 0x00020000, 
      Specific        = 0x00040000, 
      NoVertex        = 0x00000000   };
    enum Correction {
      Corrected       = 0x00001000, 
      Pileup          = 0x00001100, 
      PileupCalo      = 0x00001110, 
      PileupTrack     = 0x00001120, 
      PileupSTVF      = 0x00001121, 
      PileupJetVertex = 0x00001122, 
      PileupJetArea   = 0x00001140, 
      NotCorrected    = 0x00000000   };

    static const Types::bitmask_t clearedStatusTag   = StandAlone      | NoVertex | NotCorrected;     
    static const Types::bitmask_t generalSummedTag   = Total           | NoVertex | NotCorrected;     
    static const Types::bitmask_t generalContribTag  = StandAlone      | NoVertex | NotCorrected;     
    static const Types::bitmask_t generalHardTermTag = ContributedTerm | Specific | Pileup;           
    static const Types::bitmask_t generalSoftTermTag = ContributedTerm | NoVertex | 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(Types::bitmask_t rec,Types::bitmask_t vtx,Types::bitmask_t cor) { return ( rec | vtx ) | cor; }

      static Types::bitmask_t total(Vertex vtx=Nominal,Correction cor=NotCorrected)              { return setPattern(Total,vtx,cor); }
      static Types::bitmask_t contributedTerm(Vertex vtx=Nominal,Correction cor=NotCorrected)    { return setPattern(ContributedTerm,vtx,cor); }
      static Types::bitmask_t correctedTerm(Vertex vtx=Nominal,Correction cor=Corrected) { return setPattern(CorrectedTerm,vtx,cor); }
      static Types::bitmask_t alternativeTerm(Vertex vtx=Nominal,Correction cor=NotCorrected)     { return setPattern(AlternativeTerm,vtx,cor); }

      static bool hasPattern(Types::bitmask_t sw,Types::bitmask_t pat) { return ( sw & pat ) == pat; }

      static bool isTotal(Types::bitmask_t sw)           { return hasPattern(sw,Total); }
      static bool isContributedTerm(Types::bitmask_t sw) { return hasPattern(sw,ContributedTerm); }
      static bool isAlternativeTerm(Types::bitmask_t sw) { return hasPattern(sw,AlternativeTerm); }
      static bool isStandAlone(Types::bitmask_t sw)      { return hasPattern(sw,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

---