/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/AssociationUtils/AssociationUtils/OverlapRemovalToolLegacy.h

#ifndef ASSOCIATIONUTILS_OVERLAPREMOVALTOOL_H
#define ASSOCIATIONUTILS_OVERLAPREMOVALTOOL_H

// Framework includes
#include "AsgTools/AsgTool.h"

// EDM includes
#include "xAODBase/IParticle.h"

// Local includes
#include "AssociationUtils/IOverlapRemovalTool.h"
#include "AssociationUtils/OverlapRemovalDefs.h"

class OverlapRemovalTool : public virtual IOverlapRemovalTool,
                           public asg::AsgTool
{

    ASG_TOOL_CLASS(OverlapRemovalTool, IOverlapRemovalTool)

  public:

    OverlapRemovalTool(const std::string& name);
    ~OverlapRemovalTool();


    virtual StatusCode initialize() override;



    virtual StatusCode removeOverlaps(const xAOD::ElectronContainer* electrons,
                                      const xAOD::MuonContainer* muons,
                                      const xAOD::JetContainer* jets,
                                      const xAOD::TauJetContainer* taus = 0,
                                      const xAOD::PhotonContainer* photons = 0) override;

    virtual StatusCode removeOverlaps(const xAOD::ElectronContainer* electrons,
                                      const xAOD::MuonContainer* muons,
                                      const xAOD::JetContainer* jets,
                                      const xAOD::TauJetContainer* taus,
                                      const xAOD::ElectronContainer* looseElectrons,
                                      const xAOD::MuonContainer* looseMuons,
                                      const xAOD::PhotonContainer* photons = 0) override;

    virtual StatusCode removeEleJetOverlap(const xAOD::ElectronContainer& electrons,
                                           const xAOD::JetContainer& jets) override;

    virtual StatusCode removeMuonJetOverlap(const xAOD::MuonContainer& muons,
                                            const xAOD::JetContainer& jets) override;

    virtual StatusCode removeEleMuonOverlap(const xAOD::ElectronContainer& electrons,
                                            const xAOD::MuonContainer& muons) override;

    virtual StatusCode removeTauJetOverlap(const xAOD::TauJetContainer& taus,
                                           const xAOD::JetContainer& jets) override;

    virtual StatusCode removeTauEleOverlap(const xAOD::TauJetContainer& taus,
                                           const xAOD::ElectronContainer& electrons) override;

    virtual StatusCode removeTauMuonOverlap(const xAOD::TauJetContainer& taus,
                                            const xAOD::MuonContainer& muons) override;

    virtual StatusCode removePhotonEleOverlap(const xAOD::PhotonContainer& photons,
                                              const xAOD::ElectronContainer& electrons) override;

    virtual StatusCode removePhotonMuonOverlap(const xAOD::PhotonContainer& photons,
                                               const xAOD::MuonContainer& muons) override;

    virtual StatusCode removePhotonPhotonOverlap(const xAOD::PhotonContainer& photons) override;

    virtual StatusCode removePhotonJetOverlap(const xAOD::PhotonContainer& photons,
                                              const xAOD::JetContainer& jets) override;


  protected:

    // I might use these next methods for the loose lepton ID

    StatusCode isLooseEleForTauEleOR(const xAOD::Electron* electron, bool& pass);
    StatusCode isLooseMuonForTauMuonOR(const xAOD::Muon* muon, bool& pass);

    bool isBJet(const xAOD::Jet* jet);

    bool objectOverlaps(const xAOD::IParticle* obj,
                        const xAOD::IParticleContainer& container,
                        double dR);

    bool objectsOverlap(const xAOD::IParticle* p1, const xAOD::IParticle* p2,
                        double dRMax, double dRMin = 0);

    StatusCode addOverlapObjectLink(const xAOD::IParticle* p1,
                                    const xAOD::IParticle* p2);

    double deltaR2(const xAOD::IParticle* p1, const xAOD::IParticle* p2);
    double deltaR(const xAOD::IParticle* p1, const xAOD::IParticle* p2);

    bool isInputObject(const xAOD::IParticle* obj);

    bool isRejectedObject(const xAOD::IParticle* obj);

    bool isSurvivingObject(const xAOD::IParticle* obj)
    { return isInputObject(obj) && !isRejectedObject(obj); }

    void setOverlapDecoration(const xAOD::IParticle* obj, bool result);

    void setObjectPass(const xAOD::IParticle* obj)
    { setOverlapDecoration(obj, false); }

    void setObjectFail(const xAOD::IParticle* obj)
    { setOverlapDecoration(obj, true); }

    bool isDecorated(const xAOD::IParticleContainer& container);

    void initializeDecorations(const xAOD::IParticleContainer& container);

    void resetDecorations(const xAOD::IParticleContainer& container);


    bool checkTrackParticles(const xAOD::ElectronContainer& container);
    bool checkSharesTrackDecoration(const xAOD::ElectronContainer& container);
    bool sharesTrack(const xAOD::IParticle* obj);
    StatusCode setSharesTrackDecoration(const xAOD::IParticle* obj, bool sharesTrack);
    void initializeSharesTrackDecoration(const xAOD::ElectronContainer& container);   //need wrapper?

  private:

    //
    // Configurable properties
    //

    std::string m_inputLabel;
    std::string m_overlapLabel;

    std::string m_bJetLabel;

    bool m_linkOverlapObjects;

    float m_electronJetDR;
    float m_jetElectronDR;
    float m_muonJetDR;
    float m_tauJetDR;
    float m_tauElectronDR;
    float m_tauMuonDR;
    float m_photonElectronDR;
    float m_photonMuonDR;
    float m_photonPhotonDR;
    float m_photonJetDR;

    std::string m_tauEleOverlapID;
    float m_tauMuOverlapMuPt;
    float m_tauMuOverlapTauPt;

    bool m_writeSharedTrackFlag;
    bool m_useSharedTrackFlag;

    //
    // Accessors and decorators
    //

    ort::inputAccessor_t* m_inputAccessor;
    ort::outputDecorator_t* m_outputDecorator;
    ort::inputAccessor_t* m_bJetAccessor;
    ort::objLinkDecorator_t* m_overlapLinkDecorator;
    ort::sharedTrackDecorator_t* m_sharedTrackDecorator;
    ort::sharedTrackAccessor_t* m_sharedTrackAccessor;

}
#if not defined(__GCCXML__) and not defined(__ROOTCLING__) and not defined(__MAKECINT__)
__attribute__((deprecated))
#endif
; // class OverlapRemovalTool

#endif

---