/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/TrigMuonEfficiency/TrigMuonEfficiency/ElectronTriggerMatching.h

#ifndef __ElectronTriggerMatching_h__
#define __ElectronTriggerMatching_h__

#include <string>
#include <map>
#include <set>
#include "TTree.h"
#include "TLorentzVector.h"

#include "TrigMuonEfficiency/LeptonTriggerMatching.h"

class ElectronTriggerMatching : public LeptonTriggerMatching {
  public:
    struct DielectronChainInfo {
      public:
        std::string chain;
        std::pair<std::string, std::string> thresholds;
        std::string tightness;
        bool isSymmetric;
        bool isValid;

        DielectronChainInfo(const std::string& chain_="") :
          chain(chain_), thresholds(), tightness(), isSymmetric(false), isValid(false) { }

        
        void dump() const {
          std::cout << "DielectronChainInfo: chain = " << chain
                << " thresholds.first = " << thresholds.first << " thresholds.second = " << thresholds.second
                << " isSymmetric = " << isSymmetric << " isValid = " << isValid << "\n";
        }
    };

    ElectronTriggerMatching(const MTT__D3PDEvent *d3pd,
                            TTree *TrigConfTree=0)
      : LeptonTriggerMatching(d3pd, TrigConfTree),
        m_DielectronChainMap()
    {
      if (TrigConfTree) {
        std::vector<std::string> skip;
        skip.push_back("EF_e");
        skip.push_back("EF_2e");
        readTrigConfTree(TrigConfTree, skip);

      } else {
        createChainIdMapFromFile();
      }
    }
    virtual ~ElectronTriggerMatching(){}



    bool match(const double eta,
               const double phi,
               const std::string& chain);

    bool matchDielectron(const TLorentzVector& electron1,
                         const TLorentzVector& electron2,
                         const std::string& chain,
                         bool& result1,
                         bool& result2);

    bool matchDielectron(const TLorentzVector& electron1,
                         const TLorentzVector& electron2,
                         const std::string& chain,
                         std::pair<bool, bool>& result1,
                         std::pair<bool, bool>& result2);

    int matchDielectron_python(const TLorentzVector& electron1,
                               const TLorentzVector& electron2,
                               const std::string& chain)
    {
      std::pair<bool, bool> result1, result2;
      matchDielectron(electron1, electron2, chain, result1, result2);
      return (result1.second << 3 | result2.first << 2 | result2.second << 1 | result1.first << 0);
    }



    bool matchElectronMuon(const TLorentzVector& electron,
                           const TLorentzVector& muon,
                           const std::string& chain);



  private:
    std::map<std::string, DielectronChainInfo> m_DielectronChainMap; // [chain - <threshold1, threshold2>]

    double matchedTrackDetail(EFelectron& efElectronId,
                              const EFelectron& usedEfElectronId,
                              const double eta,
                              const double phi,
                              const std::string& chainEventTrigger,
                              const std::string& threshold = std::string());


    std::pair<bool, bool> matchDielectron(const TLorentzVector& electron1,
                                          const TLorentzVector& electron2,
                                          const DielectronChainInfo& chainInfo);

    bool decodeDielectronChain(DielectronChainInfo& chainInfo);

    bool decodeElectronMuonChain(const std::string& chain,
                                 std::string& threshold);

    void createChainIdMapFromFile(); //implementation in ElectronChainIdMap.h
};

#endif //__ElectronTriggerMatching_h__
// eof

---