BaseOverlapTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ASSOCIATIONUTILS_BASEOVERLAPTOOL_H
#define ASSOCIATIONUTILS_BASEOVERLAPTOOL_H
 
// System includes
#include <string>
#include <memory>
 
// Framework includes
#include "AsgTools/AsgTool.h"
 
// EDM includes
#include "xAODBase/IParticle.h"
 
// Columnar includes
#include "ColumnarCore/ColumnarTool.h"
#include "ColumnarCore/ObjectColumn.h"
#include "ColumnarCore/ParticleDef.h"
 
// Local includes
#include "AssociationUtils/OverlapDecorationHelper.h"
#include "AssociationUtils/OverlapLinkHelper.h"
#include "AssociationUtils/IOverlapTool.h"
 
namespace ORUtils
{

  class BaseOverlapTool : public asg::AsgTool, public columnar::ColumnarTool<>, virtual public IOverlapTool
  {

      ASG_TOOL_CLASS(BaseOverlapTool, asg::IAsgTool)
 
    public:

      BaseOverlapTool(const std::string& name);

      StatusCode initialize() override final;

      virtual void callEvents (columnar::EventContextRange events) const override;
 
    protected:

      virtual StatusCode initializeDerived()
      { return StatusCode::SUCCESS; }

      template<columnar::RegularContainerIdConcept CI1,columnar::RegularContainerIdConcept CI2,typename CM>
      StatusCode handleOverlap(const columnar::ObjectId<CI1,CM>& testParticle,
                               const columnar::ObjectId<CI2,CM>& refParticle) const;
 

      template<typename XAODContainer,columnar::RegularContainerIdConcept CI,typename CM>
      StatusCode checkForXAODContainer(columnar::ObjectRange<CI,CM> cont, std::string_view message) const
      {
        if constexpr (CM::isXAOD) {
          if(typeid(cont.getXAODObjectNoexcept()) != typeid(XAODContainer) &&
            typeid(cont.getXAODObjectNoexcept()) != typeid(ConstDataVector<XAODContainer>)) {
            ATH_MSG_ERROR(message);
            return StatusCode::FAILURE;
          }
        }
        return StatusCode::SUCCESS;
      }


      std::string m_inputLabel;
      std::string m_outputLabel;

      bool m_outputPassValue;

      bool m_linkOverlapObjects;

      bool m_enableUserPrio;

 
    protected:
 
      struct BaseAccessors final : columnar::ColumnarTool<>
      {
        columnar::Particle1Accessor<columnar::ObjectColumn> m_particles1Acc {*this, ""};
        columnar::Particle2Accessor<columnar::ObjectColumn> m_particles2Acc {*this, ""};
        using ColumnarTool::ColumnarTool;
      };
      std::unique_ptr<BaseAccessors> m_baseAccessors {std::make_unique<BaseAccessors> (this)};

      std::unique_ptr<OverlapDecorationHelper<columnar::Particle1Def>> m_decHelper1;
      std::unique_ptr<OverlapDecorationHelper<columnar::Particle2Def>> m_decHelper2;

      std::unique_ptr<OverlapLinkHelper<columnar::Particle1Def>> m_objLinkHelper1;
      std::unique_ptr<OverlapLinkHelper<columnar::Particle2Def>> m_objLinkHelper2;

 
 
    protected:
 
      void initializeDecorations(columnar::Particle1Range container) const {
        m_decHelper1->initializeDecorations (container); }
      void initializeDecorations(columnar::Particle2Range container) const {
        m_decHelper2->initializeDecorations (container); }
      [[nodiscard]] char getObjectPriority(columnar::Particle1Id obj) const {
        return m_decHelper1->getObjectPriority (obj); }
      [[nodiscard]] char getObjectPriority(columnar::Particle2Id obj) const {
        return m_decHelper2->getObjectPriority (obj); }
      [[nodiscard]] bool isSurvivingObject(columnar::Particle1Id obj) const {
        return m_decHelper1->isSurvivingObject (obj);}
      [[nodiscard]] bool isSurvivingObject(columnar::Particle2Id obj) const {
        return m_decHelper2->isSurvivingObject (obj);}
      [[nodiscard]] bool isRejectedObject(columnar::Particle1Id obj) const {
        return m_decHelper1->isRejectedObject (obj); }
      [[nodiscard]] bool isRejectedObject(columnar::Particle2Id obj) const {
        return m_decHelper2->isRejectedObject (obj); }
      void setObjectFail(columnar::Particle1Id obj) const {
        m_decHelper1->setObjectFail (obj); }
      void setObjectFail(columnar::Particle2Id obj) const {
        m_decHelper2->setObjectFail (obj); }
      template<columnar::ContainerIdConcept CI>
      StatusCode addObjectLink (columnar::Particle1Id p1, columnar::ObjectId<CI> p2) const {
        return m_objLinkHelper1->addObjectLink (p1, p2); }
      template<columnar::ContainerIdConcept CI>
      StatusCode addObjectLink (columnar::Particle2Id p1, columnar::ObjectId<CI> p2) const {
        return m_objLinkHelper2->addObjectLink (p1, p2); }

 
  }; // class BaseOverlapTool
 
  //---------------------------------------------------------------------------
  // Handle overlap condition
  //---------------------------------------------------------------------------
  template<columnar::RegularContainerIdConcept CI1,columnar::RegularContainerIdConcept CI2,typename CM>
  StatusCode BaseOverlapTool ::
  handleOverlap(const columnar::ObjectId<CI1,CM>& testParticle,
                const columnar::ObjectId<CI2,CM>& refParticle) const
  {
    // Apply user-priority override
    if(!m_enableUserPrio ||
       getObjectPriority(testParticle) <=
       getObjectPriority(refParticle))
    {
      if constexpr (CM::isXAOD)
      {
        const float invGeV = 1e-3;
        ATH_MSG_DEBUG("  Found overlap " << testParticle.getXAODObject().type() <<
                      " pt " << testParticle.getXAODObject().pt()*invGeV);
      } else
      {
        ATH_MSG_DEBUG("  Found overlap " << testParticle);
      }
      setObjectFail(testParticle);
      if(m_linkOverlapObjects) {
        ATH_CHECK( addObjectLink(testParticle, refParticle) );
      }
    }
    return StatusCode::SUCCESS;
  }
 
 
} // namespace ORUtils
 
#endif