BmumuThinningTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
//
#ifndef DERIVATIONFRAMEWORK_BmumuThinningTool_H
#define DERIVATIONFRAMEWORK_BmumuThinningTool_H
 
#include "DerivationFrameworkBPhys/CfAthAlgTool.h"
#include "DerivationFrameworkInterfaces/IThinningTool.h"
#include "GaudiKernel/ToolHandle.h"
#include "xAODBPhys/BPhysHypoHelper.h"
 
#include <string>
 
class IThinningSvc;
 
namespace SG {
  class AuxElement;
}
 
namespace xAOD {
  class AuxContainerBase;
}
 
namespace DerivationFramework {
  class BmumuThinningTool : public CfAthAlgTool, public IThinningTool {
 
    // useful typedefs
    typedef xAOD::BPhysHelper::pv_type pv_type;
    typedef ElementLink<xAOD::TrackParticleContainer> TrackParticleLink;
    
  public:
    //  Note: may later be migrated to xAODBPhys/BPhysHelper
    static std::map<pv_type, std::string> PvTypeToVarNameMap;
    
  public:
    BmumuThinningTool(const std::string& t, const std::string& n,
              const IInterface* p);
    ~BmumuThinningTool();
    StatusCode initialize();
    StatusCode finalize();
    virtual StatusCode doThinning() const;
 
  protected:
    bool pass(const SG::AuxElement& em, std::string hypo) const;
    const xAOD::TrackParticle* getTrackParticle(const xAOD::Vertex* vtx,
                        std::string name) const;
 
    template<typename TYPE>
    StatusCode applyThinMask(SG::ThinningHandle<TYPE> &trkCont,
           const std::vector<bool>& trkMask,
           bool doAnd) const;
 
 
    StatusCode matchMuons(const xAOD::MuonContainer* muCont,
              std::vector<bool>& muMask,
              xAOD::BPhysHelper& vtx,
              std::string counterName) const;
    StatusCode markOrigMuons(const xAOD::MuonContainer* muCont,
                 const xAOD::MuonContainer* cmuCont,
                 std::vector<bool>& muMask,
                 std::vector<bool>& cmuMask,
                 std::string counterName,
                 bool allowFastSync=true) const;
    StatusCode markCalibMuons(const xAOD::MuonContainer* muCont,
                  const xAOD::MuonContainer* cmuCont,
                  std::vector<bool>& muMask,
                  std::vector<bool>& cmuMask,
                  std::string counterName,
                  bool allowFastSync) const;
    StatusCode markTrksForSelMuons(const xAOD::TrackParticleContainer*
                   trkPartCont,
                   std::vector<bool>& trkMask,
                   const xAOD::MuonContainer* muCont,
                   std::vector<bool>& muMask,
                   std::string counterName) const;
    StatusCode markMuonsForSelTracks(const xAOD::TrackParticleContainer*
                     trkPartCont,
                     std::vector<bool>& trkMask,
                     const xAOD::MuonContainer* muCont,
                     std::vector<bool>& muMask,
                     std::string counterName) const;
 
    std::vector<std::string>
      filterAuxElements(const xAOD::AuxContainerBase* auxCont,
            std::string pattern) const;
    void selectAuxElements(const xAOD::AuxContainerBase* auxCont,
               std::vector<std::string>& vLinkNames,
               std::vector<pv_type>&     vLinkTypes,
               std::string pattern) const;    
    void selectAuxElements(const xAOD::AuxContainerBase* auxCont,
               std::vector<std::string>& vLinkNames,
               std::vector<std::string>  vPrefixes,
               std::vector<pv_type>&     vLinkTypes,
               std::string pattern) const;    
    std::string dumpVS(const std::vector<std::string>& vs,
               const std::string header="",
               size_t nBlanks=0) const;
    void logWrappedMsg(const std::string& str, const MSG::Level lvl) const;
    std::string checkMaskConsistency(const std::vector<bool>& mask1,
                     const std::vector<bool>& mask2,
                     const std::string name1,
                     const std::string name2,
                     const std::string header="") const;
 
  private:
    ServiceHandle<IThinningSvc> m_thinningSvc;
    std::string                 m_trkPartContName;
    std::vector<std::string>    m_vtxContNames;
    std::vector<std::string>    m_vtxPassFlags;
    std::string                 m_PVContName;
    std::vector<std::string>    m_refPVContNames;
    std::string                 m_muonContName;
    std::string                 m_calMuonContName;
    std::string                 m_ctBranchBaseName;
    std::vector<std::string>    m_ctBranchPrefixes;
    bool                        m_alignPassToVertexList;
    bool                        m_keepPVTracks;
    bool                        m_matchCalMuons;
    bool                        m_markMuons;
    bool                        m_markCalMuons;
    bool                        m_syncMuonsBothWays;
    bool                        m_keepCloseTracks;
    bool                        m_keepSelMuonTracks;
    bool                        m_keepSelCalMuonTracks;
    bool                        m_keepSelTrackMuons;
    bool                        m_keepSelTrackCalMuons;
    bool                        m_allowFastMuonMaskSync;
    bool                        m_thinPVs;
    bool                        m_thinRefPVs;
    bool                        m_thinTracks;
    bool                        m_thinMuons;
    bool                        m_vertexAnd;
    bool                        m_trackAnd;
    bool                        m_muonAnd;
    
    bool m_doCloseTracks;
    bool m_doPVs;
    bool m_doRefPVs;
    bool m_doMuons;
    bool m_doCalMuons;
    bool m_doTracks;
 
    mutable std::vector<std::vector<std::string> > m_vvOrigPVLinkNames;
    mutable std::vector<std::vector<pv_type> >     m_vvOrigPVLinkTypes;
    mutable std::vector<std::vector<std::string> > m_vvRefPVLinkNames;
    mutable std::vector<std::vector<pv_type> >     m_vvRefPVLinkTypes;
 
    mutable std::vector<std::vector<std::string> > m_vvCtLinkNames;
    mutable std::vector<std::vector<pv_type> >     m_vvCtLinkTypes;
 
  };
  
} // namespace DerivationFramework
 
#endif // DERIVATIONFRAMEWORK_BmumuThinningTool_H