VGammaORTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef GAMMAORTOOLS_VGAMMAORTOOL_H
#define GAMMAORTOOLS_VGAMMAORTOOL_H
 
#include <vector>
#include <map>
#include <string>
#include "MCTruthClassifier/MCTruthClassifier.h"
#include <xAODTruth/TruthParticleContainer.h>
#include <xAODTruth/TruthParticle.h>
#include "AsgTools/AsgTool.h"
#include "AsgTools/AnaToolHandle.h"
#include "GammaORTools/IVGammaORTool.h"
 
/****************************************************************************/
 
class VGammaORTool: public asg::AsgTool, virtual public IVGammaORTool {
  ASG_TOOL_CLASS(VGammaORTool, IVGammaORTool)
public:
  VGammaORTool(const std::string& name);
  virtual ~VGammaORTool() override;

  //    four vectors (can be used if the full truth record is not available or broken)
  virtual StatusCode inOverlap(bool& result,
                   const std::vector<TLorentzVector>* leptons=0,
                   const std::vector<TLorentzVector>* photons=0,
                   const std::vector<int>* lepton_origins=0,
                   const std::vector<int>* photon_origins=0) const override;

  //    four vectors (can be used if the full truth record is not available or broken)
  virtual StatusCode photonPtsOutsideDr(std::vector<float>& result,
                    const std::vector<TLorentzVector>* leptons=0,
                    const std::vector<TLorentzVector>* photons=0,
                    const std::vector<int>* lepton_origins=0,
                    const std::vector<int>* photon_origins=0) const override;

  //    four vectors (can be used if the full truth record is not available or broken)
  virtual StatusCode photonPtsOutsideDrs(std::map<float, std::vector<float> >& result,
                     const std::vector<TLorentzVector>* leptons=0,
                     const std::vector<TLorentzVector>* photons=0,
                     const std::vector<int>* lepton_origins=0,
                     const std::vector<int>* photon_origins=0) const override;

  virtual bool frixioneIsolated(const xAOD::TruthParticle& photon,
                        const xAOD::TruthParticleContainer& truthParticles,
                        float dR0, float exponent, float epsilon) const override;
 

  std::vector<TLorentzVector> getPhotonP4s(const xAOD::TruthParticleContainer& truthParticleContainer) const;

  std::vector<TLorentzVector> getLeptonP4s(const xAOD::TruthParticleContainer& truthParticleContainer) const;
 
private:
 
  // This function performs the actual algorithm needed for OR, if one of the public functions is called
  // It returns a vector of ordered photon pTs for multiple lepton-photon dR cuts
  StatusCode photonPtsOutsideDrs(std::map<float, std::vector<float> >& result,
                 const std::vector<float>& drCuts,
                 const std::vector<TLorentzVector>* leptons=0,
                 const std::vector<TLorentzVector>* photons=0,
                 const std::vector<int>* lepton_origins=0,
                 const std::vector<int>* photon_origins=0) const;
 
  // Set the right leptons, get them either from user or the current event
  StatusCode setInput(std::vector<TLorentzVector>& leptons_out,
              std::vector<TLorentzVector>& photons_out,
              const std::vector<TLorentzVector>* lepton_p4s,
              const std::vector<TLorentzVector>* photon_p4s,
              const std::vector<int>* lepton_origins,
              const std::vector<int>* photon_origins) const;
 
  // Filter out photons whose origin is among the veto origins (typically photons from hadron decays)
  std::vector<TLorentzVector> filterPhotonOrigins(const std::vector<TLorentzVector>&, const std::vector<int>&) const;
 
  // Filter out leptons whose origin is among the veto origins (typically photons from hadron decays)
  // Return list containing all leptons from prefered origins (from hard process) first
  // As fallback leptons from origins not explictly vetoed (e.g. unkown origins) are added at the end of the list
  std::vector<TLorentzVector> filterLeptonOrigins(const std::vector<TLorentzVector>&, const std::vector<int>&) const;
 
  // Check whether a lepton originates from tau decay 
  bool isFromTau(const xAOD::TruthParticle& lepton, int nRecursions=0) const;
  
  // Internal helper function to check wheter photon pTs are compatible with configured overlap cuts
  bool checkPhotonPts(const std::vector<float>& photon_pts) const;
 
  // Implementation of Eq 3.4 in  https://arxiv.org/pdf/hep-ph/9801442
  float frixioneFunc(float dR, float dR0, float exponent, float epsilon) const;
 
  // MCTruthClassifier
  asg::AnaToolHandle<MCTruthClassifier> m_truthClassifier;
 
  // CONFIGURATION =================================================
 
  // Number of leptons expected in process (e.g. 2 for Z+gamma, 1 for W+gamma, 4 for ZZ+gamma)
  // If this is set to a negative number, all possible leptons are considered
  // Per default this includes leptons from unkown origins, so it is more robuts to set a positive value
  // for m_n_leptons as a upper limit
  int m_n_leptons;
  // Lepton flavours considered,  signed pdgIds  (only relevant if leptons are not provided by user)
  // If possible, restricting flavors can increase the robustness
  std::vector<int> m_lepton_pdgIds;
  // Lepton origins preferred when searching prompt leptons
  // These origins should be associated with the hard process
  // Origin codes are defined here:
  // https://svnweb.cern.ch/trac/atlasoff/browser/PhysicsAnalysis/MCTruthClassifier/trunk/MCTruthClassifier/MCTruthClassifierDefs.h
  std::vector<int> m_preferred_lepton_origins;
  // Lepton origins of leptons never used as prompt
  // These should be e.g. hadron origins
  std::vector<int> m_lepton_veto_origins;
 
  // Photon origins vetoed when searching prompt leptons
  // These should be photons from hadron/tau decays
  // Origin codes are defined here:
  // https://svnweb.cern.ch/trac/atlasoff/browser/PhysicsAnalysis/MCTruthClassifier/trunk/MCTruthClassifier/MCTruthClassifierDefs.h
  std::vector<int> m_veto_photon_origins;
 
    // p_T (y) cut(s) used in inOverlap function -- only 1 for Vgamma OR, 2 for Vgammagamma
  std::vector<float> m_photon_pT_cuts;
  // delta R (l,y) cut for used in inOverlap and photonPtsOutsideDr function
  float m_dR_lepton_photon_cut;
  // List of dR cuts for which the highest photon pT will be determined by photonPtsOutsideDrs function
  std::vector<float> m_dR_lepton_photon_cuts;
 
  // Require photons to be Frixione isolated (https://arxiv.org/abs/hep-ph/9801442)?
  bool m_use_gamma_iso;
  // Isolation cone used for Frixione isolation
  float m_frixione_dR;
  // exponent in Eq 3.4 in https://arxiv.org/pdf/hep-ph/9801442
  float m_frixione_exponent;
  // epsilon in Eq 3.4 in https://arxiv.org/pdf/hep-ph/9801442
  float m_frixione_epsilon;
  // Which stable particles are *not* considered in isolation? Usually leptons and photons.
  std::vector<int> m_abs_pdgids_excluded_from_iso;
 
  // Minimum photon pT considered in algorithm -- increase speeds up algorithm as less photons need to be classified
  float m_min_considered_photon_pT;
 
};
 
 
 
#endif //> !GAMMAORTOOLS_VGAMMAORTOOL_H